[mf6xx.git] / doc / diploma_thesis / text / dip_text.tex

%FIXME
% vlna
% \caption{} bez tečky na konci
% \item[] a \item s tečkou na konci
% odsazování zdrojáků
% parametry funkce. Většinou nejsou, ale u prvních výskytů by se hodily

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Úvod}
\section{Motivace, cíl}
Zadání této práce vzešlo z akademického prostředí a reaguje na nedostatek studijních materiálů v českém jazyce pro začátečníky, popisujících vývoj ovladačů (v tomto případě PCI zařízení) pro operační systém GNU/Linux.

Text popisuje základní aspekty práce s PCI zařízeními v jádře Linux a uvádí dva konkrétní způsoby implementace ovladače zařízení PCI. Text obsahuje pouze nezbytné množství teorie, která je podložená četnými příklady pro snadnější pochopení čtenářem. Pro čtenáře neznalého psaní programů těsně svázaných s hardwarem se snažím názorně vysvětlit základní principy a úskalí tohoto druhu programování. V případě dalšího zájmu o problematiku může čtenář sáhnout po knize \cite{devicedriver}.

Kromě samotného popisu vývoje PCI ovladačů je cílem práce částečně implementovat funkce karty Humusoft MF624 do emulačního programu Qemu tak, aby si případný zájemce mohl vše vyzkoušet, aniž by fyzicky vlastnil hardware.

\section{Dostupné materiály}
V českém jazyce dosud vyšla pouze jedna tištěná kniha, která se zabývá problematikou vývoje pro jádro Linux. Jedná se o knihu \cite{jadrosystemu} od Lukáše Jelínka. Je dělena do 3 základních částí:
\begin{itemize}
\item \textit{Vnější rozhraní jádra}
\item \textit{Vývoj ovladačů}
\item \textit{Pohled dovnitř jádra}
\end{itemize}

Jednotlivá témata jsou popsána pouze stručně (kniha je koncipována spíše jako příručka než jako učebnice) a pro studenta nižšího ročníku, neznalého vývoje jaderných ovladačů zařízení nemá příliš velký přínos.

Za nejpřínosnější knihu, zabývající se psaním ovladačů pro Linux, považuji anglicky psanou knihu \cite{devicedriver} od autorů Jonathan Corbet, Alessandro Rubini a Greg Kroah-Hartman. Knihu je možné stáhnout zdarma ve formátu PDF\footnote{\url{http://lwn.net/Kernel/LDD3/}}.

\begin{figure}[h!]
        \begin{center}
        \begin{minipage}[b]{0.4\linewidth}
                \includegraphics[width=50mm]{img/jadro-systemu-linux.jpg}
        \end{minipage}
        \begin{minipage}[b]{0.4\linewidth}
                \includegraphics[width=50mm]{img/lddrivers.jpg}
        \end{minipage}
        \caption{\textit{Vlevo}: Kniha Lukáše Jelínka (v českém jazyce). 
                \textit{Vpravo}: kniha od autorů Jonathan Corbet, Alessandro Rubini a Greg Kroah-Hartman (v anglickém jazyce)}
        \label{knihy}
        \end{center}
\end{figure}



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Hardware}
\section{Základní principy komunikace s hardwarem}
Jak je možné ovládat hardwarové periferie pomocí programu (software) je nejsnazší ukázat na příkladu jednočipového počítače.

\ibox{Mikrokontrolér, neboli jednočipový počítač, má velikost pouze jednoho čipu. Obsahuje přitom procesor, paměť, vstupně-výstupní zařízení a jiné. Je obvyklé, aby mikrokontrolér obsahoval tzv. GPIO piny. 
\begin{description}
\item[GPIO piny (General Purpose Input/Output)] -- u těchto pinů je možné nastavit, zda má být jejich hodnota čtena (slouží jako vstupní piny -- skrze ně vstupuje informace) nebo zda chceme jejich hodnotu nastavovat (tj. výstupní piny).%
%\item[A/D převodník] -- Převádí analogový (spojitý) signál na diskrétní (nespojitý). Příklad: Na vstup A/D převodníku přivedeme napětí 2,4 V. Z registru odpovídajícímu tomuto převodníku si v digitální podobě mikroprocesor vyčte hodnotu odpovídající 2,4.
%\item[D/A převodník] -- Opačně od A/D převodníku převádí digitální signál na analogový. Příklad: Do registru odpovídajícímu D/A převodníku zapíše mikroprocesor hodnotu odpovídající např. 3,5 V. Na výstupu bude možné změřit napětí 3,5 V (s určitou malou odchylkou).
\end{description}%
}

Prvním způsobem, jak změnit stav GPIO pinu (ať už nastavení, zda se má jednat o vstupní/výstupní pin nebo jakou hodnotu má mít v případě, že je výstupní) je provedení operace zápisu na určitou adresu v paměťovém adresním prostoru (ta je pevně daná a liší mezi jednotlivými architekturami mikrokontrolérů), tato adresa odpovídá \textbf{registru}\footnote{Registr může být pro zjednodušení považován za malou paměťovou buňku. Změna její hodnoty přímo ovlivňuje stav hardware. V dokumentaci ke konkrétnímu mikrokontroléru/\-mikroprocesoru/\-programovatelnému integrovanému obvodu je uvedeno, jakou funkci mají jednotlivé bity registru.} GPIO pinu. Vnitřní uspořádání mikrokontroléru, dle adresy na kterou bylo zapisováno, rozpozná, že provedená operace zápisu nebyla určena pro změnu hodnoty vnitřní paměti, ale je určena pro změnu hodnoty registru a z toho plynoucí změny stavu určité části hardwaru. Zapsaná hodnota se tedy projeví změnou stavu GPIO pinu. Tato možnost je nejjednodušší a je možná v případě, že jsou hardwarové periferie mapovány do určité části tzv. \textbf{paměťového prostoru}.\footnote{Také označováno jako MMIO -- \textit{Memory-mapped input/output}}

\begin{figure}[h!]
        \begin{center}
        \includegraphics[width=130mm]{img/gpio.pdf}
        \caption{Registr odpovídající GPIO pinům. Změnou tohoto registru je možné měnit chování GPIO pinů}
        \label{gpio_pins}
        \end{center}
\end{figure}


Jiným způsobem změny stavu registru je použití jiné instrukce než která se používá pro paměťové operace -- tj. místo zápisu na adresu v paměťovém prostoru vyhrazenou pro GPIO registr, se provede zápis do tzv. \textbf{vstupně-výstupního prostoru}\footnote{Také označován zkratkou PIO -- \textit{Programmed input/output} nebo jako I/O adresní prostor} na adresu (v tomto případě označovanou jako \textbf{port}) odpovídající registru GPIO pinů. Adresy paměťového a vstupně-výstupního prostoru spolu nijak nesouvisí. V případě zápisu a čtení do/z portu I/O adresního prostoru je potřeba z dokumentace \textbf{přesně vědět} jak široká (kolikabitová) slova je možné zapisovat/číst. 

\ibox{V případě architektury IA-32 (označované také jako x86) máme k dispozici paměťový a vstupně-výstupní adresní prostor. Vstupně výstupní adresní prostor je pouze 16bitový, zatímco paměťový je (\textit{pro zjednodušení nebereme ohled na PAE -- Physical Address Extension}) 32bitový. Toto rozdělení přetrvává z historických důvodů -- i přesto je již možné některá zařízení mapovat do paměťového prostoru. (Znázorněno na obrázku \ref{mmio}.)}

Hlavní rozdíly mezi chováním paměťové buňky a registru zařízení jsou:
\begin{itemize}
\item Změnou hodnoty registru je možné měnit stav zařízení/periferie odpovídající danému registru.
\item V případě zápisu do registru a jeho okamžitém čtení, nemusí být přečtená hodnota shodná se zapisovanou -- v tom případě byla hodnota registru změněna hardwarem.
\item V případě čtení z registru může být spuštěn tzv. \textbf{side effect}, kdy hardware na toto čtení reaguje změnou stavu, podobně jako by byl proveden zápis do registru (Příklad: Ihned po vyčtení hodnoty registru A/D převodníku se spustí nový převod a původní hodnota se přepíše novou). Side effects mohou nastat i při zápisu do registru. 
\item Při zápisu a čtení do/z registru si je nutné přesně rozlišovat, kolika-bitové operace zápisu/čtení smějí být použity (8-, 16-, 32bitové).
\end{itemize}

\begin{figure}[h!]
        \begin{center}
        \includegraphics[width=100mm]{img/mmio.pdf}
        \caption{Paměťový a vstupně-výstupní prostor u architektury IA-32}
        \label{mmio}
        \end{center}
\end{figure}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\clearpage
%\newpage
\section{PCI sběrnice}\label{pcich}
%Přesný popis PCI sběrnice je mimo rozsah a zaměření této práce. Pokusím se však zmínit a názorně vysvětlit principy využívané touto sběrnicí, které je nutné alespoň částečně znát při implementaci ovladačů PCI zařízení.

PCI (\textit{Peripheral Component Interconnect}) je standard paralelní sběrnice využívaný v počítačích různých architektur. Šířka paralelně přenášených dat je 32 nebo v modernější, méně často používané verzi, 64 bitů. Sběrnice je orientována na přenos zpráv oproti přímé komunikaci mezi zařízeními\footnote{Příklad: FIXME}

Komunikace mezi zařízeními připojenými na sběrnici a procesorem zajišťuje tzv. \textit{PCI most} (PCI bridge). Propojení více nezávislých sběrnic v jednom počítači jsou zajištěny také PCI mosty.

\subsection{Historie}
V roce 1990 začala práce na specifikaci PCI v laboratořích firmy Intel. První specifikace definující jak komunikační protokol, tak vzhled konektoru a slotu, byla zveřejněna 30. dubna 1993 (jedná se o PCI 2.0). PCI sběrnice se poté začala objevovat v počítačích architektury PC XT a PowerPC.

V pozdějších letech se původní standard dočkal vylepšení -- zvýšení šířky paralelní sběrnice z 32 bitů na 64 bitů a zrychlení z 33 MHz na 66 Mhz a výše. Tyto pokročilejší verze se však příliš neujaly.
\subsection{Konektory}
Pro spojení mezi kartou a sběrnicí je potřeba pouze konektor na straně sběrnice -- tzv. slot. V závislosti na napájecím napětí (3,3 V nebo 5 V) jsou na kartách klíčovací zářezy -- tyto zářezy znemožňují zasunutí \textit{napěťově} nekompatibilní karty do slotu. Jsou však karty, které mají tyto zářezy oba, díky čemuž může být karta použita v libovolném slotu (Obr. \ref{pci}).

\begin{figure}[h!]
        \begin{center}
        \begin{minipage}[b]{0.4\linewidth}
                \includegraphics[width=57mm]{img/pci_schema2.png}
        \end{minipage}
        \begin{minipage}[b]{0.4\linewidth}
                \includegraphics[width=50mm]{img/pci2.jpg}
        \end{minipage}
        \caption{\textit{Vlevo}: Schéma znázorňující rozdíly mezi konektory pro karty s napájením 3,3 V a 5 V. \textit{Vpravo}: Reálná fotografie PCI konektorů}
        \label{pci}
        \end{center}
\end{figure}


\subsection{Dynamická konfigurace a konfigurační adresní prostor}\label{pci_conf}
Mezi hlavní výhody PCI sběrnice (oproti její předchůdkyni -- sběrnici ISA) patří dynamická konfigurace připojených zařízení: Ve většině případů probíhá komunikace mezi hostitelským systémem a připojenou (a nakonfigurovanou) PCI kartou zápisem/čtením do určité paměťové (nebo vstupně-výstupní) oblasti. U starší sběrnice ISA si každá karta pevně určila, kam se její část paměti namapuje -- v takovém případě mohl nastat problém, že více než jedna karta mapovala svoji paměť na stejnou adresu (nebo se jednotlivá mapování překrývala). PCI sběrnice tomuto problému předchází takovým způsobem, že každá z karet nese informaci o tom, kolik jak velkých paměťových nebo I/O regionů potřebuje namapovat -- o samotné mapování se poté postará PCI most.

Informaci o tom, kolik (a jaké) paměti karta bude potřebovat má před nakonfigurováním uloženu v tzv. \textbf{Base Address Registrech} -- BAR0--BAR5\footnote{FIXME Ve skutečnosti funguje vyčtení požadované velikosti z registru karty PCI mostem takovým způsobem, že se PCI most snaží do každého BAR registru zapsat 0xFF a poté zapsanou hodnotu přečíst -- do BAR registru je možné zapsat pouze .... bla bla}. Poté co se PCI mostu podaří tuto hodnotu přečíst a požadovanou paměť alokovat, zapíše zpět do daného registru adresu, na které se alokovaná paměť nachází. Tu si poté pro potřeby komunikace vyčte ovladač zařízení, který je součástí operačního systému.


Kromě výše zmíněných 6 BAR registrů, obsahují PCI zařízení i následující registry:
\begin{description}
\item[Vendor ID]~\\Obsahuje unikátní 16bitové číslo identifikující výrobce zařízení. Za poplatek je udělováno PCI-SIG (\textit{PCI Special Interest Group}) organizací.\footnote{V Debianu, po nainstalování balíčku \texttt{hwdata}, se seznam těchto identifikátorů nachází v souboru \texttt{/usr/share/hwdata/pci.ids}}
\item[Device ID]~\\Obsahuje 16bitové číslo identifikující model zařízení. Hodnotu tohoto identifikátoru si volí sám výrobce zařízení.
\item[Class code]~\\Označuje (ve 24 bitech) druh zařízení -- zda se jedná např. o grafickou kartu, zvukovou kartu nebo kartu zpracovávající signál.
\item[Subsystem Vendor ID] -- Podobá se \texttt{Vendor ID}. V případě, že karta využívá PCI řadič třetí strany, jako \texttt{Vendor ID} se zobrazí ID výrobce tohoto řadiče. Aby bylo možné zařízení odlišit od jiného, které využívá stejný řadič, skutečné ID zařízení bude uloženo v tomto registru.
\item[Subsystem ID]~\\Opět se jedná o údaj podobný \texttt{Device ID} sloužící k rozlišení karet postavených na univerzálním řadiči.
\end{description}

Registry \texttt{Vendor ID}, \texttt{Device ID} (příp. ještě \texttt{Subsystem Vendor ID} a \texttt{Subsystem ID}) slouží operačnímu systému k jednoznačné identifikaci zařízení, při volbě správného ovladače.


\begin{figure}[h!]
        \begin{center}
        \includegraphics[width=80mm]{img/pci-config-space2.pdf}
        \caption{Obsah 256 bajtů konfiguračního prostoru PCI karty (zvýrazněny jsou nejdůležitější registry)}
        \label{sa1}
        \end{center}
\end{figure}

Výše popsané registry (spolu s ostatními, které zde nebyly popsány) se nacházejí v 256bitovém tzv. \textbf{konfiguračním adresním prostoru} karty\footnote{Po paměťovém a vstupně-výstupním adresním prostoru je zde třetí -- konfigurační -- adresní prostor.}. Přístup do konfiguračního adresního prostoru je na architektuře IA-32 možný pomocí zapsání adresy (\textit{kam chceme v konfiguračním prostoru zapisovat}) a dat (\textit{která chceme do konfiguračního prostoru zapsat}) do dvou speciálních I/O portů, které jsou pro tuto operaci vyhrazeny.


\subsection{Přerušení}
Sběrnice PCI obsahuje čtyři linky přerušení a všechny z nich jsou dostupné každému zařízení. Přerušení mohou být sdílená, tudíž o jedno přerušení se může dělit více zařízení. Pro snazší sdílení přerušení jsou úrovňově spouštěná (oproti hranovému spouštění nedochází k promeškání přerušení).

V pozdějších revizích PCI specifikací je přidána podpora pro přerušení signalizované zprávou. V tomto případě zařízení oznamuje svůj požadavek na obsloužení zápisem do paměti PCI mostu -- ten poté tento požadavak směruje dále k procesoru.

\subsection{Budoucnost}
V posledních letech je na poli osobních počítačů PCI sběrnice nahrazována její nástupkyní -- sběrnicí PCIe (PCI Express). Ta je na rozdíl od PCI sériová a dosahuje rychlostí až 16 GB/s. I přesto je sběrnice PCI stále využívána mnohými zařízeními -- převážně v průmyslu.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Humusoft MF624}
\begin{figure}[h!]
        \begin{center}
        \includegraphics[width=150mm]{img/mf624.jpg}
        \caption{Měřící karta Humusoft MF624}
        \label{mf624}
        \end{center}
\end{figure}

Měřící karta Humusoft MF624 (obr. \ref{mf624}), připojitelná k počítači pomocí PCI sběrnice, má pro účely výkladu psaní ovladačů několik nesporných výhod:
\begin{itemize}
\item Komunikace (na úrovni ovladače) s kartou probíhá snadno pochopitelným, přímo\-čarým způsobem, kdy je pouze zapisováno (nebo čteno) do registrů karty (bude vysvětleno dále).
\item Je možné si ověřit správnou funkci napsaného ovladače -- např. připojením LED diody k digitálnímu výstupu nebo měřením napětí na výstupu D/A převodníku.
\end{itemize}

Karta MF624 najde své uplatnění hlavně v laboratorním prostředí -- v případech, když je potřeba vytvořit styk mezi počítačem a senzorem/jiným zařízením, které poskytuje analogový, resp. digitální signál (v tom případě jsou použity A/D převodníky, resp. digitální vstupy). Kartu je možné použít pro řízení akčního členu/zařízení -- k dispozici jsou D/A převodníky a digitální výstupy.

Karta disponuje následujícícmi funkcemi (v popisu implementace ovladačů se omezím pouze na A/D, D/A převodníky a digitální vstupy/výstupy):
\begin{itemize}
\item 8 digitálních vstupů (TTL kompatibilní logické úrovně)
\item 8 digitálních výstupů (TTL kompatibilní logické úrovně)
\item 8 14bitových A/D převodníků (rozsah $\pm$10 V)
\item 8 14bitových D/A převodníků (rozsah $\pm$10 V)
\item 4 časovače/čítače
\item 4 vstupy inkrementálních snímačů
\end{itemize}

\subsection{Komunikace s kartou}\label{hum_komunikace}
Komunikace s kartou není nijak složitá -- zjednodušeně by se dala popsat následovně:
\begin{itemize}
\item V případě čtení hodnoty digitálních vstupů, přečte se hodnota registru určeného právě digitálním vstupům -- v případě zápisu na digitální výstupy, se zapíše do registru určeného digitálním výstupům.
\item V případě čtení hodnoty A/D převodníku, se nejprve zapíše do konfiguračního registru A/D převodníku hodnota odpovídající požadované konfiguraci. Poté se již z registru náležícího A/D převodníku vyčte požadovaná hodnota.
\end{itemize}

Které registry karta obsahuje, jakou mají funkci a kde jsou umístěny je možné zjistit z manuálu ke kartě -- ten je možné stáhnout z oficiálních internetových stránek výrobce: \url{http://www2.humusoft.cz/www/datacq/manuals/mf624um.pdf}.

Na straně 11 je k vidění první důležitá tabulka (zde tab. \ref{tab_bar}):

\begin{table}[h!]
        \begin{center}
        \begin{tabular}{|p{2cm}|p{4cm}|c|c|}
        \hline \textbf{Region} & \textbf{Function} & \textbf{Size (bytes)} & \textbf{Width (bytes)} \\ 
        \hline BADR0 (memory mapped) & PCI chipset, interrupts, status bits, special functions & 32 & 32 \\ 
        \hline BADR1 (memory mapped) & A/D, D/A, digital I/O & 128 & 16/32 \\ 
        \hline BADR2 (memory mapped) & Counter/timer chip & 128 & 32 \\ 
        \hline 
        \end{tabular} 
        \caption{Paměťové regiony, které využívá karta MF624}
        \label{tab_bar}
        \end{center}
\end{table}

Z ní je patrné, že karta využívá 3 regiony\footnote{V manuálu je uvedeno, že se jedná o regiony odpovídající BAR0, BAR1 a BAR2 registrům -- na počítačích s procesorem rodiny IA-32 a s operačním systémem GNU/Linux však karta využívá BAR0, BAR2 a BAR4. Důvod rozdílu mezi skutečností a manuálem není jasný. Na tuto skutečnost se musí při implementaci ovladače brát zřetel.} mapované do paměťového adresního prostoru -- o velikostech 32, 128 a 128 bajtů. Pro čtení/zápis z/do nich je potřeba používat 32-, 16-, 32bitové operace\footnote{V manuálu je uvedeno, že za určitých podmínek je možné k BAR1 přistupovat i pomocí 32bitových operací. V této práci bych se tomuto složitějšímu přístupu rád vyhnul. Částečná implementace karty MF624 do emulátoru Qemu (Popsaná v příloze \ref{qemu}) umožňuje \textbf{pouze} 16bitový přístup do BAR1 paměťového regionu.}

\subsection{Digitální vstupy a výstupy}
Z tabulky \ref{tab_bar} lze vyčíst informaci, že registry ovládající digitální vstupy a výstupy leží v regionu BAR1 (sloupec 2). Dále je potřeba se podívat na přehled registrů náležejících tomuto paměťovému regionu (v oficiálním manuálu na straně 12) -- tomu odpovídá tabulka (s menšími úpravami) \ref{tab_bar1}.

\begin{table}[h!]
        \begin{center}
        \begin{tabular}{|p{17mm}|c|c|}
        \hline \textbf{Address (BADR1 offset)} & \textbf{Read} & \textbf{Write} \\ 
        \hline 0x00 & \textbf{ADDATA} -- A/D data & ADCTRL -- A/D control \\ 
        \hline 0x02 & \textbf{ADDATA} -- A/D data mirror &  \\ 
        \hline 0x04 & \textbf{ADDATA} -- A/D data mirror &  \\ 
        \hline 0x06 & \textbf{ADDATA} -- A/D data mirror &  \\ 
        \hline 0x08 & \textbf{ADDATA} -- A/D data mirror &  \\ 
        \hline 0x0A & \textbf{ADDATA} -- A/D data mirror &  \\ 
        \hline 0x0C & \textbf{ADDATA} -- A/D data mirror &  \\ 
        \hline 0x0E & \textbf{ADDATA} -- A/D data mirror &  \\ 
        \hline 0x10 & \textbf{DIN} -- Digital input & \textbf{DOUT} -- Digital output \\ 
        \hline 0x20 & \textbf{ADSTART} -- A/D SW trigger & \textbf{DA0} -- D/A 0 data \\ 
        \hline 0x22 &  & \textbf{DA1} -- D/A 1 data \\ 
        \hline 0x24 &  & \textbf{DA2} -- D/A 2 data \\ 
        \hline 0x26 &  & \textbf{DA3} -- D/A 3 data \\ 
        \hline 0x28 &  & \textbf{DA4} -- D/A 4 data \\ 
        \hline 0x2A &  & \textbf{DA5} -- D/A 5 data \\ 
        \hline 0x2C &  & \textbf{DA6} -- D/A 6 data \\ 
        \hline 0x2E &  & \textbf{DA7} -- D/A 7 data \\ 
        \hline 
        \end{tabular} 
        \caption{Registry karty obsažené v regionu BAR1}
        \label{tab_bar1}
        \end{center}
\end{table}

Na devátém řádku jsou zmíněny \texttt{DIN} (Digital input) a \texttt{DOUT} (Digital output) registry. Z této tabulky je patrná pozice těchto registrů v paměťovém prostoru (t.j. offset v bytech vůči adrese BAR1).

Jak jsou data v registrech reprezentována, je možné si přečíst (v oficiálním manuálu) na straně 16, kde jsou tyto dva registry podrobně popsány (zde tabulka \ref{tab_din} a \ref{tab_dout}). 
První sloupec určuje, kterých bitů se daný řádek týká. V druhém sloupci je informace o funkci. Třetí sloupec udává výchozí hodnotu. Z toho, co je v tabulkách uvedeno, plyne, že pro čtení 8bitového digitálního vstupu stačí přečíst spodních 8 bitů DIN registru, horních 8 bitů je potřeba ignorovat. Stejně tak pro nastavení 8bitového digitálního výstupu se zapíše požadovaná hodnota do spodních 8 bitů registru DOUT, horních 8 bitů je potřeba ignorovat.

\begin{table}[h!]
        \begin{center}
        \begin{tabular}{|c|c|c|}
        \hline \textbf{Bit} & \textbf{Description} & \textbf{Default} \\ 
        \hline 7:0 & \textbf{Digital input 7:0.} Reads digital input port. & 1 \\ 
        \hline 15:8 & Reserved & N/A \\ 
        \hline 
        \end{tabular} 
        \caption{DIN -- Digital Input Register Format}
        \label{tab_din}
        \end{center}
\end{table}

\begin{table}[h!]
        \begin{center}
        \begin{tabular}{|c|c|c|}
        \hline \textbf{Bit} & \textbf{Description} & \textbf{Default} \\ 
        \hline 7:0 & \textbf{Digital output 7:0.} Writes to digital output port. & 0 \\ 
        \hline 15:8 & Reserved & N/A \\ 
        \hline 
        \end{tabular} 
        \caption{DOUT -- Digital Output Register Format}
        \label{tab_dout}
        \end{center}
\end{table}


\subsection{A/D převodníky}
Karta MF624 obsahuje osm 14bitových A/D převodníků s pevně stanoveným rozsahem $\pm$10 V. Jejich vyčtení může probíhat následujícím způsobem:

\begin{itemize}
\item Nejprve se v registru ADCTRL zvolí, které A/D převodníky mají být čteny. 
Každý z A/D převodníků je reprezentován jedním bitem. Zápisem 1 do daného bitu se nastaví, že bude daný A/D převodník aktivní -- 0 ho deaktivuje. Je možné zvolit více než jeden A/D převodník.
\item Čtením registru ADSTART se spustí převod na zvolených A/D převod\-nících. Přečtená hodnota se dále nepoužívá.
\item V případě, že se provedl převod na všech zvolených A/D převodnících, je EOLC bit (17. bit) GPIOC registru nastaven na 0 (jinak je v 1).
\item Výslednou hodnotu je možné přečíst z registru ADDATA, který je typu FIFO. To znamená, že opětovným čtením jednoho registru jsou vyčítány jednotlivé naměřené hodnoty z měřených A/D převodníků v pořadí od 0 do 7.

Jinou možností je místo čtení registru ADDATA číst některý z jeho \textit{zrcadlených registrů} (celkem je jich 7, v manuálu jsou označeny jako \textit{BADR1 + 0x02} až \textit{BADR1 + 0x0E}). Tyto registry se chovají \textbf{zcela stejně} jako registr ADDATA, pouze leží na jiných adresách. Příklad: pokud byly aktivovány první čtyři A/D převodníky, po převodu je možné výslednou hodnotu vyčíst opakovaným čtením registru ADDATA nebo čtením registru ADDATA, ADDATA1, ADDATA2, ADDATA3 přesně v tomto pořadí. Čtení z registrů v jiném pořadí bude stále vracet hodnoty převodníků 0--4.
\end{itemize}

Hodnota vyčtená z A/D převodníků je ve formátu dvojkového doplňku -- příklad konkrétních hodnot je v tabulce \ref{tab_adval}.


\begin{table}[h!]
        \begin{center}
        \begin{tabular}{|c|c|}
        \hline \textbf{Digitální hodnota} & \textbf{Analogová hodnota} \\ 
        \hline 0x3FFF & -0.0012 V \\ 
        \hline 0x2000 & -10.0000 V \\ 
        \hline 0x1FFF &  9.9988 V \\ 
        \hline 0x0000 &  0.0000 V \\ 
        \hline 
        \end{tabular} 
        \caption{Kódování vstupních hodnot A/D převodníku}
        \label{tab_adval}
        \end{center}
\end{table}

\subsection{D/A převodníky}
Karta MF624 obsahuje také osm 14bitových D/A převodníků s rozsahem $\pm$10 V.

Nastavení výstupních hodnot D/A převodníků může probíhat následujícím způsobem:

\begin{itemize}
\item Hodnota v aditivním kódu (tabulka \ref{tab_daval}) se zapíše do jednoho z osmi registrů DA0--DA7 odpovídajícího D/A převodníku, který má být nastaven.
\item Bit DACEN (26. bit) registru GPIOC je potřeba nastavit na 1, jinak jsou výstupy D/A převodníků připojeny na \textit{zem}.
\item Bit LDAC (23. bit) registru GPIOC je potřeba nastavit na 0, aby byl spuštěn samotný převod D/A převodníků (jinak zůstane zapsaná hodnota pouze v registru, výstupní hodnota D/A převodníku zůstane nezměněna).
\end{itemize}


\begin{table}[h!]
        \begin{center}
        \begin{tabular}{|c|c|}
        \hline \textbf{Digitální hodnota} & \textbf{Analogová hodnota} \\ 
        \hline 0x3FFF &  9.9988 V \\ 
        \hline 0x2000 &  0.0000 V \\ 
        \hline 0x1FFF & -0.0012 V \\ 
        \hline 0x0000 & -10.0000 V \\ 
        \hline 
        \end{tabular} 
        \caption{Kódování vstupních hodnot D/A převodníku}
        \label{tab_daval}
        \end{center}
\end{table}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\newpage
\section{Humusoft MF614}
\begin{figure}[h!]
        \begin{center}
        \includegraphics[width=150mm]{img/mf614.jpg}
        \caption{Měřící karta Humusoft MF614}
        \label{mf614}
        \end{center}
\end{figure}

Karta Humusoft MF614 má podobné funkce a využití jako karta MF624. Ve skutečnosti se jedná o její předchůdkyni. 

Karta disponuje následujícími funkcemi:

\begin{itemize}
\item 8 digitálních vstupů (TTL kompatibilní logické úrovně)
\item 8 digitálních výstupů (TTL kompatibilní logické úrovně)
\item 8 12bitových A/D převodníků (volitelné rozsahy $\pm$10 V, $\pm$5 V, 0--5 V, 0--10 V)
\item 4 12bitových D/A převodníků (rozsah $\pm$10 V)
\item 4 časovače/čítače
\item 4 vstupy inkrementálních snímačů
\end{itemize}

\subsection{Komunikace s kartou}
Způsob komunikace s kartou MF614 se mírně liší od MF624.

Po nahlédnutí do manuálu (dostupný ze stránek výrobce: \url{http://www2.humusoft.cz/www/datacq/manuals/mf614um.pdf}) je z tabulky 9 (zde tab. \ref{tab_mf614_bars}) patrné, že karta využívá více regionů než MF624, přičemž některé jsou mapovány do paměti, jiné do vstupně-výstupního adresního prostoru. Po prohlédnutí tabulky popisující rozložení registrů (zde tab. \ref{tab_mf614_regs}) je zřejmé, že pro přístup k digitálním vstupům/výstupům a analogovým vstupům/výstupům jsou použity vstupně-výstupní regiony BAR0, BAR2. 

\begin{table}[h!]
        \begin{center}
        \begin{tabular}{|c|c|c|}
        \hline \textbf{Region}          & \textbf{Function}                                             & \textbf{Size (bytes)} \\ 
        \hline BADR0 (I/O mapped)       & Board programming registers                           & 32 \\ 
        \hline BADR1 (I/O mapped)       & Reserved                                                                      & 4 \\ 
        \hline BADR2 (I/O mapped)       & OX9162 local configuration registers          & 32 \\ 
        \hline BADR3 (memory mapped) & OX9162 local configuration registers     & 4096 \\ 
        \hline BADR4 (memory mapped) & Board programming registers                              & 4096 \\ 
        \hline 
        \end{tabular} 
        \caption{Paměťové a vstupně-výstupní regiony, které využívá karta MF614}
        \label{tab_mf614_bars}
        \end{center}
\end{table}


\begin{table}[h!]
        \begin{center}
        \begin{tabular}{|c|c|c|}
        \hline \textbf{Address} & \textbf{Read} & \textbf{Write} \\ 
        \hline BADR0 + 0x0 & \textbf{ADLO} -- A/D data low                      & \textbf{ADCTRL} -- A/D control \\ 
        \hline BADR0 + 0x1 & \textbf{ADHI} -- A/D data high                     &  \\ 
        \hline BADR0 + 0x2 & \textbf{9513A} -- Data read                                & \textbf{9513A} -- Data write \\ 
        \hline BADR0 + 0x3 & \textbf{9513A} -- Command read                     & \textbf{9513A} -- Command write \\ 
        \hline BADR0 + 0x4 &  &  \\ 
        \hline BADR0 + 0x5 &  &  \\ 
        \hline BADR0 + 0x6 & \textbf{DIN} -- Digital input                      & \textbf{DOUT} -- Digital output \\ 
        \hline BADR0 + 0x7 &  &  \\ 
        \hline BADR0 + 0x8 & \textbf{DALE} -- D/A latch enable          & \textbf{DA0LO} -- D/A 0 data low byte \\ 
        \hline BADR0 + 0x9 &                                                                            & \textbf{DA0HI} -- D/A 0 data high byte \\ 
        \hline BADR0 + 0xA &                                                                            & \textbf{DA1LO} -- D/A 1 data low byte \\ 
        \hline BADR0 + 0xB &                                                                            & \textbf{DA1HI} -- D/A 1 data high byte \\ 
        \hline BADR0 + 0xC &                                                                            & \textbf{DA2LO} -- D/A 2 data low byte \\ 
        \hline BADR0 + 0xD &                                                                            & \textbf{DA2HI} -- D/A 2 data high byte \\ 
        \hline BADR0 + 0xE &                                                                            & \textbf{DA3LO} -- D/A 3 data low byte \\ 
        \hline BADR0 + 0xF &                                                                            & \textbf{DA3HI} -- D/A 3 data high byte \\ 
        \hline \ldots & \ldots & \ldots \\      
        \hline BADR2 + 0x10 & \textbf{STATUS} -- Status register & \\   
        \hline 
        \end{tabular} 
        \caption{Registry karty MF614 náležící digitálním vstupům/výstupům a analogovým vstupům/výstupům}
        \label{tab_mf614_regs}
        \end{center}
\end{table}

Jednotlivé registry v těchto regionech jsou 8bitové, proto je potřeba při čtení/zápisu používat pouze 8bitové funkce. 16bitové hodnoty jsou rozděleny do dvou 8bitových registrů -- v takovém případě, obsahuje-li registr ve svém názvu písmena \textbf{LO}, jedná se o spodní bajt, zatímco \textbf{HI} značí horní bajt. Výsledná 16bitová hodnota se získá složením dvou 8bitových:
\begin{verbatim}
   u8 regAHI, regALO;
   u16 regA;
   
   regA = regALO | (regAHI << 8);
\end{verbatim}

\subsection{Digitální vstupy a výstupy}
Pro nastavení hodnoty digitálních výstupů se zapíše požadovaná hodnota do registru DOUT, kde jeden bit odpovídá jednomu digitálnímu výstupu. Pro čtení digitálních vstupů je potřeba přečíst registr DIN.

\subsection{A/D převodníky}
Čtení A/D převodníků je u karty MF614 oproti MF624 trochu složitější, hlavně díky tomu, že je u převodníků potřeba nastavit, v jakém rozsahu bude provedeno měření. Je možné vybírat mezi rozsahy -10--10 V, -5--5 V, 0--10 V, 0--5 V. 

K nastavení vlastností A/D převodníků slouží registr ADCTRL (přeložená tab. \ref{tab_mf614_adctrl}). Bity 2:0 slouží k volbě jednoho z osmi A/D převodníků, které budou při příštím měření použity. Dekadická hodnota určující pořadí A/D převodníku je uložena ve třech bitech jako binární číslo (t.j. $0_{10} = 000_{2}$, $1_{10} = 001_{2}$, $2_{10} = 010_{2}$, $3_{10} = 011_{2}$, $4_{10} = 100_{2}$, \ldots). 

Bity 3 a 4 slouží k nastavení použitého rozsahu (způsob nastavení viz tabulka \ref{tab_mf614_rng}).

Bity 5, 6 a 7 nemají žádnou funkci a musí bát nastaveny na 0, 1, 0.

\begin{table}[h!]
        \begin{center}
        \begin{tabular}{|c|c|c|}
        \hline \textbf{Bit} & \textbf{Jméno} & \textbf{Popis} \\ 
        \hline  7                       &                               & Musí být nastaveno na 0 \\ 
        \hline  6                       &                               & Musí být nastaveno na 1 \\ 
        \hline  5                       &                               & Musí být nastaveno na 0 \\ 
        \hline  4                       & RNG                   & Nastavení měřeného rozsahu A/D převodníku (tab. \ref{tab_mf614_rng}) \\ 
        \hline  3                       & BIP                   & Nastavení, zda bude měřený rozsah \textit{bipolární} (tab. \ref{tab_mf614_rng}) \\ 
        \hline  2, 1, 0         & A2, A1, A0    & Výběr A/D převodníku pro příští měření \\ 
        \hline 
        \end{tabular} 
        \caption{Funkce jednotlivých bitů registru ADCTRL}
        \label{tab_mf614_adctrl}
        \end{center}
\end{table}

\begin{table}[h!]
        \begin{center}
        \begin{tabular}{|c|c|c|}
        \hline \textbf{RNG} & \textbf{BIP} & \textbf{Vstupní rozsah [V]} \\ 
        \hline  0                       &       0                       & 0--5 V \\ 
        \hline  1                       &       0                       & 0--10 V \\ 
        \hline  0                       &       1                       & -5--5 V \\ 
        \hline  1                       &       1                       & -10--10 V \\ 
        \hline 
        \end{tabular} 
        \caption{Volba rozsahu A/D převodníku}
        \label{tab_mf614_rng}
        \end{center}
\end{table}

Vyčtení hodnoty A/D převodníku může probíhat následujícím způsobem:

\begin{itemize}
\item Nejprve se v registru ADCRTL zvolí, který A/D převodník bude čten a který měřící rozsah bude použit.
\item Zápis do registru ADCTRL automaticky spouští převod.
\item Je-li CC bit (2. bit) registru STAT nastaven na 0, převod již byl ukončen.
\item Data je poté možné přečíst z registru ADLO a ADHI -- jedná se o 8bitové registry, které je potřeba pro získání 12 bitové výsledné hodnoty \textit{složit} dohromady. Je-li nastaven unipolární rozsah měření (t.j. 0--5 V nebo 0--10 V) je měřená hodnota kódována jako binární číslo. V případě bipolárního rozsahu je hodnota kódována pomocí dvojkového doplňku.
\end{itemize}

\subsection{D/A převodníky}
Karta MF614 obsahuje 4 D/A převodníky. Ty mají pevně nastavený výstupní rozsah -10--10 V a nevyžadují žádnou konfiguraci.

Nastavení výstupu D/A převodníků může probíhat následujícím způsobem:
\begin{itemize}
\item Do registru DA$x$LO a DA$x$HI (kde $x$ může nabývat hodnot 0, 1, 2, 3 a určuje, ke kterému D/A převodníku registr patří) se zapíše hodnota k převodu. 12bitová hodnota je do 8bitových registrů rozdělena takovým způsobem, že 8 LSB je zapsáno do DA$x$LO a zbývající čtyři jsou zapsány do DA$x$HI na 4 nejnižší bity, nepoužité 4 MSB registru DA$x$HI jsou vyplněny nulami.

Hodnota je zapsána v aditivním kódu (tab. \ref{tab_mf614_dac}).

\item Čtením registru DALE se spustí převod všech D/A převodníků.
\end{itemize}

\begin{table}[h!]
        \begin{center}
        \begin{tabular}{|c|c|}
        \hline \textbf{Digitální hodnota} & \textbf{Analogová hodnota} \\ 
        \hline 0xFFF & 9.9951 V \\ 
        \hline 0x800 & 0.0000 V \\ 
        \hline 0x7FF & -0.0049 V \\ 
        \hline 0x000 & -10.0000 V \\ 
        \hline 
        \end{tabular} 
        \caption{Kódování vstupních hodnot D/A převodníku}
        \label{tab_mf614_dac}
        \end{center}
\end{table}

\ibox{
\textbf{MSB} (Most Significant Bit) je označení pro bit s nejvyšší hodnotou v binárním vyjádření čísla. V obvyklém dvojkovém zápisu jde o bit nejvíce vlevo.
\\~\\
\textbf{LSB} (Least Significant Bit) je bit s nejnižší hodnotou. Jde o bit nejvíce vpravo.

\begin{center}
\texttt{1 0 1 0 1 0 1 0}\\
\texttt{MSB\hspace{2.6cm}LSB}
\end{center}}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Implementace ovladačů}
\section{Operační systém GNU/Linux}
Jako cílový operační systém, na kterém bude vysvětlena implementace základních ovladačů, byl zvolen GNU/Linux\footnote{Operační systém sestávající z GNU nástrojů a jádra Linux je označován jako GNU/Linux.}. Hlavním důvodem je dostupnost zdrojových kódů, velké množství kvalitní dokumentace, rozšířenost a vysoká kvalita. Distribucí použitou při vývoji je Debian GNU/Linux (verze jádra Linux 2.6.35) -- popsané postupy by však měly fungovat i pro jiné distribuce.

\subsection{Práce s PCI zařízeními z uživatelského prostoru}
Pro výpis všech zařízení v systému připojených pomocí sběrnice PCI slouží program \texttt{lspci}.
Po jeho spuštění bez udání parametrů bude vypsán základní seznam PCI zařízení. 

Mezi důležité parametry, použitelné při spuštění programu, patří:
\begin{description}
\item[\texttt{-t}] Zobrazí diagram znázorňující jednotlivé PCI sběrnice a mosty.
\item[\texttt{-v}, \texttt{-vv}, \texttt{-vvv}]
 Umožňuje vypisování podrobných informací o zařízeních. (Postupně od \textit{střední podrobnosti} k \textit{vysoké podrobnosti}).
\item[\texttt{-nn}] Zobrazí Vendor ID a Device ID v číselné a zároveň i textové podobě
\item[\texttt{-d [<vendor>]:[<device>]}] Zobrazí informace pouze o zařízeních odpovídajících Vendor ID, případně i Device ID
\end{description}

Příklad, jak takový výpis může vypadat:
\begin{verbatim}
$ lspci -nn -d 186c:0624 -vvv
01:0b.0 Signal processing controller [1180]: Humusoft, s.r.o. MF624 
             Multifunction I/O Card [186c:0624]
        Subsystem: Humusoft, s.r.o. MF624 Multifunction I/O Card [186c:0624]
        Control: I/O+ Mem+ BusMaster- SpecCycle- MemWINV- VGASnoop- ParErr- 
             Stepping- SERR- FastB2B- DisINTx-
        Status: Cap- 66MHz- UDF- FastB2B+ ParErr- DEVSEL=medium >TAbort- <TAbort- 
             <MAbort- >SERR- <PERR- INTx-
        Interrupt: pin A routed to IRQ 22
        Region 0: Memory at d2dffc00 (32-bit, non-prefetchable) [size=128]
        Region 1: I/O ports at b800 [size=128]
        Region 2: Memory at d2dff800 (32-bit, non-prefetchable) [size=128]
        Region 4: Memory at d2dff400 (32-bit, non-prefetchable) [size=128]
        Kernel driver in use: mf624
\end{verbatim}


Jinou možností, jak zjistit informace o PCI zařízení, je nahlédnutí do souborového systému \textit{sysfs}, kde jsou pro jednotlivá zařízení (nejen na PCI sběrnici) soubory\footnote{Tyto soubory ve skutečnosti nejsou uloženy nikde na disku, ale jsou dynamicky vytvářeny operačním systémem.}, které obsahují informace o zařízeních.

\ibox{Fyzická adresa PCI zařízení je tvořena adresou \textit{sběrnice}, adresou \textit{zařízení} a adresou \textit{logického zařízení}. PCI specifikace umožňuje, aby jeden systém obsahoval až 256 sběrnic. Každá sběrnice může obsahovat až 32 zařízení. Jedno fyzické zařízení může obsahovat až 8 logických.}

Informace o PCI zařízeních se nacházejí ve složce \texttt{/sys/bus/pci/devices/} -- jednotlivá zařízení jsou reprezentována podsložkou, jejíž název je tvořen fyzickou adresou PCI zařízení. Mezi nejdůležitější soubory, které tato podsložka obsahuje patří:

\begin{description}
\item[\texttt{vendor}] -- Obsahuje Vendor ID zařízení.
\item[\texttt{device}] -- Obsahuje Device ID zařízení.
\item[\texttt{class}] -- Obsahuje 24bitový identifikátor třídy zařízení.
\item[\texttt{subsystem\_vendor}] -- Obsahuje Subsystem Vendor ID.
\item[\texttt{subsystem\_device}] -- Obsahuje Subsystem ID.
\item[\texttt{resource}] -- Soubor obsahuje popis jednotlivých regionů (reprezentovaných BAR registry) využívaných zařízením.
\end{description}

Struktura souboru \texttt{resource} může vypadat následovně:
\begin{verbatim}
0x00000000d2dffc00 0x00000000d2dffc7f 0x0000000000020200
0x000000000000b800 0x000000000000b87f 0x0000000000020101
0x00000000d2dff800 0x00000000d2dff87f 0x0000000000020200
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x00000000d2dff400 0x00000000d2dff47f 0x0000000000020200
0x0000000000000000 0x0000000000000000 0x0000000000000000
\end{verbatim}

První sloupec označuje adresu začátku regionu, druhý jeho konec. Třetí sloupec obsahuje příznaky daného regionu. Díky nim je možné zjistit, zda se např. jedná o paměťový nebo I/O region. Tyto příznaky jsou popsány v souboru \texttt{include/linux/ioport.h} (ve zdrojových souborech jádra Linux). 




\subsection{Základní jaderný modul}\label{kern_mod}
Jádro operačního systému GNU/Linux je monolitické -- to znamená, že po zkompilování a slinkování je tvořeno jedním kusem kódu. Tento druh jádra je léty prověřen a mezi výhody patří jeho snadná implementace. Aby běžící jádro nemuselo obsahovat veškeré dostupné ovladače zařízení (nebo abychom v případě potřeby přidat do jádra ovladač pro nový hardware nemuseli celé jádro znovu kompilovat), existuje mechanismus načítání jaderných modulů za běhu, tzv. LKM -- Loadable Kernel Module. V praxi to vypadá tak, že jsou v běžícím jádře zakompilovány pouze nejnutnější ovladače, všechny ostatní si může systém nebo uživatel za běhu do jádra načíst -- v případě, že již nejsou potřeba, je možné je z jádra uvolnit.

Jak se takový jaderný modul může vypadat, je nejlepší si ukázat na příkladu:
\begin{verbatim}
 1 |  #include <linux/init.h>
 2 |  #include <linux/module.h>
 3 | 
 4 |  static int hello_init(void)
 5 |  {
 6 |      printk("Hello, world!\n");
 7 |      return 0;
 8 |  }
 9 | 
10 |  static void hello_exit(void)
11 |  {
12 |      printk("Goodbye, cruel world!\n");
13 |  }
14 | 
15 |  module_init(hello_init);
16 |  module_exit(hello_exit);
17 |  
18 |  MODULE_LICENSE("Dual BSD/GPL");
\end{verbatim}

Z příkladu je patrné, že je modul napsán v programovacím jazyce C. To platí pro většinu všech jaderných modulů (stejně jako zdrojových kódů jádra samotného). Ve skutečnosti se jedná o mírně modifikovaný standard C90.
\begin{description}
\item[Řádky 1 a 2] obsahují vložení hlavičkových souborů -- obsahují prototypy volaných funkcí a jsou nutné pro tvorbu jaderného modulu.
\item[Na řádcích 4--8] je funkce, která bude spuštěna ihned po zavedení našeho modulu do jádra. Ta obsahuje pouze volání funkce \texttt{printk()}.

Pro jednoduchost je možné s funkcí \texttt{printk()} pracovat jako s, jistě známou, funkcí \texttt{printf()} dostupnou v uživatelském prostoru -- na rozdíl od standardního výstupu se však text vypsaný funkcí \texttt{printk()} zapíše do \textit{logu} jádra. Jedním ze způsobů, jak ho zobrazit je pomocí programu \texttt{dmesg}.\\O to, že se tato funkce vykoná ihned po zavedení modulu do jádra, se postará příkaz na $\rightarrow$
\item[řádku 15] -- ten obsahuje makro \texttt{module\_init()}, kterému řekneme právě to, která funkce se má po načtení spustit.
\item[Řádek 16] obsahuje naopak makro, které udává, která funkce se má zavolat v případě, že se bude modul uvolňovat z jádra. V našem případě je to funkce na $\rightarrow$
\item[řádcích 10--13.] Tato funkce nemá na starost nic jiného než výpis krátkého textu do logu jádra.
\end{description}

\subsection{Kompilace modulu}
Dále je potřeba jaderný modul přeložit\footnote{Před samotným překladem jádra je potřeba mít k dispozici zdrojové kódy jádra. Ty je možné stáhnout z \texttt{kernel.org} nebo v distribuci Debian nainstalovat pomocí příkazu \texttt{apt-get install linux-source}}. K tomu poslouží následující \texttt{Makefile}:
\begin{verbatim}
1 |  KERNEL_VER=`uname -r`
2 |  obj-m += hello.o
3 |
4 |  all:
5 |      make -C /lib/modules/$(KERNEL_VER)/build M=$(PWD) modules
6 |  clean:
7 |      make -C /lib/modules/$(KERNEL_VER)/build M=$(PWD) clean
\end{verbatim}
Linux využívá při kompilaci systému \texttt{KBUILD}. Ten je tvořen množstvím Makefile souborů a jeho smyslem je umožnit uživateli snadnou konfiguraci před kompilací -- určující, které čáasti se do jádra zakompilují a které nikoliv. Popis toho systému je mimo rozsah této práce. Stručný popis výše zmíněného Makefile souboru:

\begin{description}
\item[Na prvním řádku] se do proměnné \texttt{KERNEL\_VER} přiřadí verze aktuálně běžícího jádra (po zavolání příkazu \texttt{uname -r}, který tuto informaci vrací)
\item[Druhý řádek] říká, že modul bude vytvářen ze zdrojového souboru \texttt{hello.c} (pod tímto názvem jsme uložili náš ukázkový modul)
\item[Na pátém řádku] (uvozeném tabelátorem) se volá (pomocí přepínače \texttt{-C}) Makefile ze systému \texttt{KBUILD}, který se nachází v adresáři spolu se zdrojovými kódy jádra. Parametrem \texttt{M} říkáme, které moduly si přejeme vytvořit -- v tomto případě jsou to ty, jejichž zdrojové soubory jsou v aktuálním adresáři (tj. \texttt{PWD}).
\end{description}

V případě, že v adresáři, ve kterém se nachází zdrojový soubor modulu \texttt{hello.c} a výše popsaný soubor \texttt{Makefile}, spustí příkaz \texttt{make}, měl by proběhnout samotný překlad:
\begin{verbatim}
$ make
make -C /lib/modules/`uname -r`/build M=/tmp/kernel_module_example modules
make[1]: Entering directory `/usr/src/linux-headers-2.6.35-28-generic'
  CC [M]  /tmp/kernel_module_example/hello.o
  Building modules, stage 2.
  MODPOST 1 modules
  CC      /tmp/hello.mod.o
  LD [M]  /tmp/hello.ko
make[1]: Leaving directory `/usr/src/linux-headers-2.6.35-28-generic'
\end{verbatim}
V aktuálním adresáři by se měl nacházet kromě různých souborů, které vzniky při překladu, i potřebný \texttt{hello.ko} -- t.j. zkompilovaný jaderný modul připravený na zavedení do jádra.

\begin{verbatim}
$ ls
hello.c  hello.ko  hello.mod.c  hello.mod.o  hello.o  
Makefile  modules.order  Module.symvers
\end{verbatim}

\subsection{Zavedení modulu}
Po úspěšném zkompilování jaderného modulu již pouze zbývá ho zavést do jádra. To se provede programem \texttt{insmod} -- ten musí být spouštěn se superuživatelským oprávněním:
\begin{verbatim}
$ sudo insmod ./hello.ko 
\end{verbatim}

V případě, že vše proběhlo správně, měl by být v logu jádra text vypisovaný modulem po jeho zavedení. To je možné ověřit:
\begin{verbatim}
$ dmesg | tail -1
[ 9245.757491] Hello, world!
\end{verbatim}
A skutečně je posledním řádkem v logu text vypsaný úspěšně zavedeným modulem.

Pro plné otestování funkčnosti ukázkového modulu, je potřeba ho ještě z jádra uvolnit. K tomu slouží program \texttt{rmmod} (opět je potřeba spouštět se superuživatelskými privilegii).
\begin{verbatim}
$ sudo rmmod hello 

$ dmesg | tail -1
[ 9612.256929] Goodbye, cruel world!
\end{verbatim}
V logu je opět nachází text vypisovaný modulem při uvolňování z jádra.


\ibox{V případě, že má být do jádra zaveden modul, jehož funkčnost a stabilita není jistá, je vhodné si uložit veškerou práci a před zavedením/uvolněním modulu do/z jádra spustit program \texttt{sync}, který uloží obsah diskových bufferů na disky.}

\subsection{Na co si dávat pozor}
Při psaní základního modulu pro jádro Linux nejsou patrné větší rozdíly oproti psaní programů pro uživatelský prostor. I přesto, že tyto rozdíly nejsou vidět, stále tady jsou. Mezi ty nejdůležitější, kterých si má být programátor vědom, patří:

\begin{description}
\item[Žádná ochrana paměti]~\\Libovolný jaderný modul má přístup k veškeré paměti počítače. V případě, že se chybně pokusí zapsat do paměti, do které by zapisovat neměl, není zde žádný mechanismus, který by mu v tom zabránil nebo ho na to alespoň upozornil.
\item[Uvolňování paměti]~\\Stejně jako pro programy psané v uživatelském prostoru platí, že nepotřebná dynamicky alokovaná paměť by měla být dealokována. V případě neuvolňování paměti programem v uživatelském prostoru je zde stále operační systém, který po skončení programu veškerou paměť uvolní. Nic takového však v jádře operačního systému nefunguje -- po uvolnění modulu z jádra není nic, co by se postaralo o alokovanou.
\item[Přímý přístup k hardwaru]~\\Základní jaderný modul psaný například nezkušeným studentem má zcela stejné možnosti přístupu k hardware jako subsystémy jádra, které se starají o správnou funkci jednotlivých ovladačů. V lepším případě může špatný ovladač způsobit pád systému, v horším např. zničení dat na disku nebo dokonce zničení hardware\footnote{Například velmi těžko opravitelné poškození firmware síťových karet Intel e1000e: \\ \url{http://www.abclinuxu.cz/clanky/jaderne-noviny/jaderne-noviny-22.-10.-2008\#pricina-chyby-poskozujici-e1000e}}.
\item[Globální proměnné]~\\Každý ovladač může být spuštěn ve více instancích, proto by v kódu neměly být globální proměnné. Proměnné, které je potřeba zpřístupnit z více míst ovladače se vloží do jedné struktury, která je poté přístupná skrze ukazatel na \textit{privátní data} ovladače. Struktura reprezentující daný ovladače většinou obsahuje ukazatel s názvem \texttt{private} nebo \texttt{priv}, který slouží k tomuto účelu.

V případě ukončení funkce ovladače musí být tato paměť uvolněna.
\end{description}

\subsection{Příkaz GOTO}
Obecně je doporučováno příkaz \texttt{goto} nepoužívat. Najdou se ale případy, kdy jeho použití usnadní práci a i přesto neznepřehlední kód. V jádře Linux se tento příkaz používá při postupném uvolňování zdrojů zařízení.

Příklad pro lepší názornost:
\begin{verbatim}
 1 |  int mf614_attach(...)
 2 |  {
 3 |      if(pci_enable_device(devpriv->pci_dev))
 4 |          goto out_exit;
 5 |  
 6 |      if(pci_request_regions(devpriv->pci_dev, "mf614"))
 7 |          goto out_disable;
 8 |  
 9 |      if (!pci_iomap(devpriv->pci_dev, 0, 0))
10 |          goto out_release;
11 |    
12 |  out_release:
13 |      pci_release_regions(devpriv->pci_dev);
14 |  out_disable:
15 |      pci_disable_device(devpriv->pci_dev);
16 |  out_exit:
17 |      return -ENODEV;
18 |  }
\end{verbatim}

Na řádcích 3, 6 a 9 jsou volány funkce, které mají za následek alokaci zdrojů zařízení. Po skončení funkce ovladače je potřeba zavolat jiné funkce, které tyto zdroje uvolní.

V případě, že by volání na řádku 6 skončilo neúspěchem, musela by být zavolána funkce \texttt{pci\_disable\_device()}, která deaktivuje zařízení (aktivované příkazem na řádku 3). V případě, že by poslední volání proběhlo neúspěšně, musela by být zavolána jak funkce \texttt{pci\_disable\_device()}, tak funkce \texttt{pci\_release\_regions()} -- to způsobuje duplikaci kódu, která vede k nepřehlednosti a může způsobovat chyby (v případě, že se omylem změní volání funkce pouze na jednom místě).

Za pomoci volání \texttt{goto} je výše popsaný problém elegantně vyřešen.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Základní funkce v prostředí jádra Linux}
V jádře Linux je kromě funkcí specifických pro práci se zařízením určitého typu, také sada obecných funkcí používaných napříč všemi ovladači. Mezi ně patří například funkce pro vypisování ladících zpráv, funkce pro alokaci a uvolňování paměti.

\subsection{Funkce \texttt{printk()} pro vypisování ladících zpráv}
\ibox{\texttt{printk(FIXME)};}
V kapitole \ref{kern_mod} již byla zmíněna funkce \texttt{printk()} v základní verzi, přirovnaná k funkci \texttt{printf()} z uživatelského prostoru. Kromě \textit{obyčejného} vypisování textu do logu jádra podporuje tato funkce navíc nastavení úrovně důležitosti zprávy a speciální formátovací řetězce.

Nastavení úrovně důležitosti zprávy se provede vložením \textit{nastavovacího} makra \textbf{před} samotný řetězec obklopený uvozovkami. Možné druhy zpráv jsou (od nejkritičtější po nejméně důležitou):
\begin{description}
\item[\texttt{KERN\_EMERG}]~\\Zpráva nejvyšší úrovně. Většinou předchází neodvratnému pádu jádra.
\item[\texttt{KERN\_ERR}]~\\Informace o vzniklé chybě. Bývá použito např. při informování o špatné funkci hardware.
\item[\texttt{KERN\_WARNING}]~\\Upozornění o nezávažné chybě.
\item[\texttt{KERN\_INFO}]~\\Informační zpráva. Může být použito např. od ovladače zařízení o úspěšném spuštění.
\item[\texttt{KERN\_DEBUG}]~\\Obyčejná ladící zpráva.
\end{description}

\vspace{5mm}

Formátovací řetězce fungují podobně jako u funkce \texttt{printf()}. Kromě známých, \texttt{\%s}, \texttt{\%u}, \texttt{\%d} a \texttt{\%x} jsou zde navíc:

\begin{description}
\item[\texttt{\%p}] Slouží k výpisu hodnoty ukazatele.
\item[FIXME]
\end{description}

Příklad nastavení typu zprávy a použití formátovacího řetězce:
\begin{verbatim}
    printk(KERN_DEBUG "I'm trashed; giving up on %p\n", ptr);
\end{verbatim}


\subsection{Funkce \texttt{kmalloc()}, \texttt{kzalloc()} pro alokaci paměti}
Problematika alokace paměti v prostředí jádra Linux je velice rozsáhlá. Pomocí speciálních funkcí je možné alokovat celé paměťové stránky nebo FIXME velkou oblast ve virtuálním paměťovém prostoru.

\ibox{\texttt{void *kmalloc(size\_t size, int flags);}}
Základní funkce pro alokaci malé paměťové oblasti (např. pro strukturu obsahující privátní data ovladače) je \texttt{kmalloc()}. Prvním parametrem je velikost alokované paměti (maximálně však 128 KB (FIXME)), druhým je příznak určující o jaký druh alokace se jedná. Nejuniverzálnější možností je \texttt{GFP\_KERNEL}.

Příklad alokace a uvolnění paměti (včetně ošetření chybových stavů):
\begin{verbatim}
  1 |  struct uio_info *info;
  2 |  info = kzalloc(sizeof(struct uio_info), GFP_KERNEL);
  3 |  if (!info) {
  4 |      return -ENOMEM;
  5 |  }
  6 |  /* práce s pamětí */
  7 |           
  8 |  kfree(info);
\end{verbatim}


\subsection{Funkce \texttt{kfree()}}
\ibox{\texttt{void kfree(void *obj);}}

Když již alokovaná paměť není potřeba, je nutné ji voláním \texttt{kfree()} uvolnit. 


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Ovladače PCI zařízení}\label{pci_driv}
\ibox{Jako nejlepší reference jednotlivých funkcí slouží zdrojové kódy jádra. Pro prohlížení zdrojových kódů jádra mohu doporučit online \textit{The Linux Cross Reference} -- \\
\url{http://lxr.linux.no/linux/}.}

Ovladače PCI zařízení jsou ve většině případů kompilovány jako jaderné moduly, dynamicky načítané za běhu jádra. Takový modul je možné buď načíst ručně, pomocí příkazu \texttt{insmod} (se zadanou absolutní cestou) nebo, nachází-li se v adresáři \texttt{/lib/modules/\$(uname -r)/} a je součástí seznamu \texttt{modules.dep}\footnote{Tento seznam je aktualizován pomocí příkazu \texttt{depmod}.} (v témže adresáři), je možné ho načíst pomocí příkazu \texttt{modprobe} (kde se jako parametr předá pouze název modulu bez koncovky \texttt{.ko}). Druhá varianta se týká všech ovladačů standardně zkompilovaných s jádrem.

V případě, že se v systému objeví nové PCI zařízení, je jádrem informován subsystém v uživatelském prostoru, který má na starosti správu \textit{hotplug} zařízení (např. \textit{udev}), o tomto zařízení. Hotplug subsystém (v uživatelském prostoru) poté na základě informací od jádra, jako je Vendor ID a Device ID , rozhodne, který ovladač má být pro dané zařízení načten. Seznam, dle kterého se rozhodne, který ovladač bude načten je v souboru \texttt{/lib/modules/\$(uname -r)/modules.pcimap}.

Každý ovladač by měl tedy obsahovat informaci o tom, pro které zařízení je určen. To je uvedeno ve struktuře \texttt{struct pci\_device\_id}.

\subsection{Struktura \texttt{struct pci\_device\_id}}\label{pci_dev_id}
Struktura \texttt{struct pci\_device\_id} slouží k identifikaci, pro která zařízení je ovladač určen. Mezi hlavní položky struktury patří \texttt{vendor}, \texttt{device}, \texttt{subvendor}, \texttt{subdevice} (typu \texttt{\_\_u32}) -- jejichž hodnota odpovídá stejnojmenným registrům v konfiguračním prostoru PCI zařízení. Jelikož může být ovladač napsán pro více zařízení, je tato struktura inicializována jako prvek pole, které je zakončeno prvkem prázdným. Různé způsoby inicializace mohou vypadat následovně:

\begin{verbatim}
 1 |  #define PCI_VENDOR_ID_HUMUSOFT          0x186c
 2 |  #define PCI_DEVICE_ID_MF624             0x0624
 3 |  #define PCI_DEVICE_ID_MF614             0x0614
 4 |  #define PCI_SUBVENDOR_ID_HUMUSOFT       0x186c
 5 |  #define PCI_SUBDEVICE_MF624             0x0624
 6 |  
 7 |  static struct pci_device_id mf624_pci_id[] = {
 8 |      {
 9 |          .vendor = PCI_VENDOR_ID_HUMUSOFT,
10 |          .device = PCI_DEVICE_ID_MF624,
11 |          .subvendor = PCI_SUBVENDOR_ID_HUMUSOFT,
12 |          .subdevice = PCI_SUBDEVICE_MF624,
13 |      },
14 |
15 |      { PCI_VENDOR_ID_HUMUSOFT, PCI_DEVICE_ID_MF614, 
16 |          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
17 |
18 |      { 0, } /* seznam je vždy zakončen prázdným prvkem */
19 |  };
\end{verbatim}

V případě, že je u zařízení rozhodující Vendor ID, ale na Subvendor ID nezáleží, je možné použít makro \texttt{PCI\_ANY\_ID} (to platí 
i pro Subdevice ID).

\ibox{\texttt{MODULE\_DEVICE\_TABLE(type, struct pci\_device\_id* name);}}

Tato struktura se -- pro nástroje v uživatelském prostoru vytvářející seznamy ovladačů -- exportuje pomocí makra \texttt{MODULE\_DEVICE\_TABLE(pci, mf624\_pci\_id)}, kde první parametr určuje typ zařízení a druhý je ukazatel na seznam typu \texttt{struct pci\_device\_id}.

\subsection{Struktura \texttt{struct pci\_driver}}\label{pci_reg}
Pro to, aby mohl se mohl ovladač PCI zařízení stát součástí jaderného PCI subsystému, je potřeba ho do zaregistrovat. To se provede voláním funkce \texttt{pci\_register\_driver()}, které se jako parametr předá ukazatel na strukturu \texttt{struct pci\_driver}. 

Tato struktura obsahuje základní informace o ovladači -- základní proměnné a ukazatele na funkce. Mezi hlavní položky patří:
\begin{description}
\item[\texttt{const char name*}]~\\Název ovladače. Tento název by měl být unikátní mezi všemi ovladači PCI zařízení. Většinou je totožný s názvem modulu.
\item[\texttt{const struct pci\_device\_id *id\_table}]~\\Pole struktur popisujících, pro která zařízení je ovladač vytvořen (viz kap. \ref{pci_dev_id}).
\item[\texttt{int (*probe) (struct pci\_dev *dev, const struct pci\_device\_id *id)}]~\\Ukazatel na funkci, která je volána PCI subsystémem, v případě, že je přítomno zařízení, pro které je tento ovladač vytvořen.
\item[\texttt{void (*remove) (struct pci\_dev *dev)}]~\\Ukazatel na funkci, která je volána poté, co je tento ovladač odstraňován ze seznamu ovladačů aktuálně používaných PCI subsystémem.
\end{description}

Příklad, jak může být struktura \texttt{pci\_driver} inicializována a následně zaregistrována:
\begin{verbatim}
 1 |  static struct pci_driver mf624_pci_driver = {
 2 |      .name = "mf624",
 3 |      .id_table = mf624_pci_id,
 4 |      .probe = mf624_pci_probe, 
 5 |      .remove = mf624_pci_remove,
 6 |  };
 7 |  pci_register_driver(&mf624_pci_driver);
\end{verbatim}


\subsection{Funkce \texttt{probe()}}\label{pci_init}
\ibox{\texttt{int probe(struct pci\_dev *dev, const struct pci\_device\_id *id);}}

Funkce \texttt{probe()} náležící danému ovladači zařízení je volána poté, co jaderný subsystém PCI zařízení zjistí, že se v systému nachází zařízení, pro které je tento ovladač určen. Tato funkce má na starosti inicializaci zařízení.

Prvním parametrem funkce předává PCI subsystém ukazatel na strukturu \texttt{struct pci\_dev}, která repre\-zentuje fyzické zařízení. V druhém parametru je předán ukazatel na strukturu, na základě které byl zvolen daný ovladač (viz kap. \ref{pci_dev_id}).

\ibox{\texttt{pci\_enable\_device(struct pci\_dev *dev);}}

V rámci inicializace ovladače je nejprve potřeba zavolat funkci \texttt{pci\_enable\_device()} -- ta se postará o inicializaci karty na úrovni hardware -- např.: přiřazení linky přerušení, zresetování registrů karty a její probuzení. Poté je již možné začít přistupovat ke zdrojům zařízení.

\subsection{Přístup ke zdrojům karty}
Jak bylo popsáno v kapitole \ref{pci_conf}, PCI zařízení může využívat až 6 paměťových nebo vstupně-výstupních regionů (označovaných jako \textit{zdroje} karty). Jejich alokace do paměťového nebo I/O prostoru počítače je zajištěna dynamicky PCI mostem. Pro přístup do regionů si musí ovladač zařízení zjistit jejich adresu a vyžádat si u operačního systému \textit{výlučný přístup}. 

\ibox{\texttt{int pci\_request\_regions(struct pci\_dev *pdev, const char *res\_name);}}

Nejprve je potřeba operační systém požádat o výlučný přístup ke zdrojům zařízení. To se provede voláním funkce \texttt{pci\_request\_regions()}. Je-li návratová hodnota zavolané funkce negativní, není ovladači umožněn přístup (jiný ovladač přistupuje ke stejné kartě nebo po jeho odstranění nedošlo k uvolnění zdrojů karty). V takovém případě by ovladač měl korektním způsobem ukončit svoji funkci a nesnažit se k zařízení přistupovat.

\ibox{\texttt{unsigned long pci\_resource\_start(struct pci\_dev *dev, int bar);}}

V případě, že volání \texttt{pci\_request\_regions()} proběhlo úspěšně, je již možné získat přístup přímo k jednotlivým regionům karty. Fyzickou adresu jednotlivých regionů lze zjistit voláním funkce \texttt{pci\_resource\_start()}, kde se jako druhý parametr uvede číslo BAR registru určujícího region (tj. 0--5). 
%Volání této funkce má pouze informativní charakter

\ibox{\texttt{unsigned long pci\_resource\_len(struct pci\_dev *dev, int bar);}}

V případě, že je potřeba zjistit velikost daného paměťového nebo I/O regionu, slouží k tomu funkce \texttt{pci\_resource\_len()}.

\ibox{\texttt{void \_\_iomem *pci\_ioremap\_bar(struct pci\_dev *pdev, int bar);}}

S ukazatelem, který vrátí funkce \texttt{pci\_request\_regions()} však není možné přímo pracovat -- je to totiž \textbf{fyzická adresa} daného regionu, ke které neumí procesor přímo přistupovat. Aby tato fyzická adresa byla přemapována na adresu \textbf{virtuální}, je potřeba zavolat funkci \texttt{pci\_ioremap\_bar()}.

K ukazateli, který vrátí volání \texttt{pci\_ioremap\_bar()} je již možné pomocí speciálních funkcí (popsány v kap. \ref{iofce}) přistupovat.

\subsection{Funkce \texttt{remove()}}

\ibox{\texttt{void remove(struct pci\_dev *dev);}}

Funkce je volána, když PCI subsystém ze svého seznamu odstraňuje strukturu \texttt{struct pci\_dev} reprezentující dané zařízení, nebo v případě, že dochází k uvolnění modulu.

Tato funkce by se měla postarat o úklid všech naalokovaných prostředků. Měla by obsahovat volání:
\begin{description}
\item[\texttt{iounmap()}]~\\Uvolnění virtuální paměti namapované voláním \texttt{pci\_ioremap\_bar()}.
\item[\texttt{pci\_release\_regions()}]~\\Uvolnění zdrojů karty, které byly zarezervovány voláním \texttt{pci\_request\_regions()}.
\item[\texttt{pci\_disable\_device()}]~\\Opak k volání \texttt{pci\_enable\_device()}.
\end{description}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Přístup k paměti zařízení}\label{iofce}
Poté co se ovladači podařilo získat přístup ke zdrojům zařízení, je nutné využít speciálních volání pro zápis/čtení do/z těchto zdrojů.

\subsection{Vstupně-výstupní adresní prostor}
Stejně jako program v jazyku symbolických instrukcí využívá pro přístup k vstupně-výstupnímu adresnímu prostoru (tj. I/O portům) zvláštní instrukce, je nutné využít speciální funkce v programech psaných ve \textit{vyšších} programovacích jazycích. V případě čtení jsou v jádře k dispozici tři volání:

\ibox{\texttt{unsigned inb(unsigned port);}}

\ibox{\texttt{unsigned inw(unsigned port);}}

\ibox{\texttt{unsigned inl(unsigned port);}}

Třetí písmeno značí o \textit{kolika-bitové} čtení se jedná: b = 8 b, w = 16 b, l = 32 b.

Pro zápis je možné využít volání:
\ibox{\texttt{void outb(unsigned char byte, unsigned port);}}

\ibox{\texttt{void outw(unsigned char byte, unsigned port);}}

\ibox{\texttt{void outl(unsigned char byte, unsigned port);}}


Třetí písmeno, stejně jako u funkcí pro čtení, značí o kolika-bitový přístup se jedná.

Funkce se stejným \textit{prototypem} jsou k dispozici i v uživatelském prostoru (potřebný hlavičkový soubor je \texttt{<sys/io.h>}).

\subsection{Paměťový adresní prostor}
I přesto, že se k přístupu k paměti zařízení mapované do paměťového adresního prostoru používá virtuální adresa, stejně jako k přístupu do operační paměti, není možné k paměti zařízení přistupovat přímo \textit{přes ukazatel}. Důvodem je to, že buď překladač (při kompilaci) nebo procesor (za běhu) zoptimalizují\footnote{Tyto optimalizace, v případě přístupu k operační paměti, urychlují vykonávání programu, aniž by negativně ovlivnily jeho funkci. V případě zápisu/čtení do/z registrů, u kterých mohou tyto operace vyvolávat tzv. \textit{side effects}, již může dojít k nesprávné funkci programu.

Příklad optimalizace: V programu se do jedné paměťové buňky ihned po sobě zapíší dvě různé hodnoty, poté se výsledná hodnota přečte -- optimalizace možná u klasického programu je taková, že se ve skutečnosti provede pouze druhý zápis, protože ten první nemá žádný efekt (hodnota je ihned přepsána druhým zápisem). V případě přístupu do registru zařízení může zápis například spouštět převod A/D převodníků -- po optimalizaci se však provede pouze jednou, nikoliv dvakrát.} sekvenci zápisů/čtení do/z paměti zařízení takovým způsobem, že se výsledek bude lišit od toho, jak to bylo v programu zamýšleno.

Těmto optimalizacím lze nejsnáze zabránit použitím volání pro čtení:

\ibox{\texttt{unsigned int ioread8(void *addr);}}

\ibox{\texttt{unsigned int ioread16(void *addr);}}

\ibox{\texttt{unsigned int ioread32(void *addr);}}

a pro zápis:

\ibox{\texttt{void iowrite8(u8 value, void *addr);}}

\ibox{\texttt{void iowrite16(u16 value, void *addr);}}

\ibox{\texttt{void iowrite32(u32 value, void *addr);}}

Číslo na konci funkce označuje o kolika-bitový přístup se jedná.

V případě, že se na paměť ve vstupně-výstupním adresním prostoru zavolá funkce 
\ibox{\texttt{void *ioport\_map(unsigned long port, unsigned int count);}} 
nebo v případě PCI zařízení funkce
\ibox{\texttt{void *pci\_iomap(struct pci\_dev *dev, int bar, unsigned long maxlen);}}

se paměť chová jakoby byla v paměťovém adresním prostoru a je nutné pro přístup k ní používat volání popsaná v této kapitole.


Pro přístup k paměti zařízení z uživatelského prostoru bohužel žádná sada funkcí není. Je potřeba nadefinovat funkce vlastní, které přistupují k paměti skrze ukazatel, který je ale označen jako \texttt{volatile}. To opět zabrání překladači v optimalizaci kódu manipulujícího s ukazatelem.

Příklad jak takové funkce mohou vypadat:

\begin{verbatim}
  1 | static inline void mf624_write32(uint32_t val, uint32_t *ptr)
  2 | {
  3 |     *(volatile uint32_t*) ptr = val;
  4 | }
  5 | static inline int32_t mf624_read32(uint32_t *ptr)
  6 | {
  7 |     return (volatile uint32_t) *ptr;
  8 | }
\end{verbatim}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{UIO ovladač}
V případě, že je vytvářen ovladač pro linuxové jádro, mělo by být rozhodnuto, kterého subsystému se stane součástí -- např. zda jde o jednoduché znakové zařízení, síťovou kartu nebo zvukovou kartu. Tato volba určí, kterou sadu pomocných funkcí bude moci ovladač používat a jakým způsobem bude zpřístupněno zařízení do uživatelského prostoru.

V případě, že jde o PCI zařízení, které nelze snadno zařadit do žádné kategorie (jedná-li se například o neobvyklou průmyslovou kartu), je možné vytvořit tzv. UIO (\textit{Userspace I/O}) ovladač. Tento ovladač se skládá ze dvou částí: jednoduchého jaderného modulu a aplikace v uživatelském prostoru. 

Mezi jeho hlavní výhody patří to, že v jádře je obsažena pouze malá obecná část, která zpřístupňuje zdroje zařízení do uživatelského prostoru (její implementace je poměrně snadná). Druhou částí je aplikace v uživatelském prostoru, která přistupuje k jednotlivým zdrojům karty a tvoří hlavní logiku ovladače. Většina vývoje tedy probíhá v uživatelském prostoru, čímž klesá riziko narušení stability jádra.

\subsection{Jaderný modul}
Jaderný modul UIO ovladače PCI zařízení by měl obsahovat:
\begin{itemize}
\item Funkci volanou PCI subsystémem při registraci ovladače
\item Volání funkcí pro namapování regionů zařízení
\item Inicializaci struktury \texttt{struct uio\_info} a registraci do UIO subsystému
\item Funkce pro \textit{úklid} a uvolnění regionů karty
\end{itemize}

Většina z těchto úkonů již byla popsána v kapitole \ref{pci_driv} a jsou zcela standardní pro jakýkoliv ovladač PCI zařízení. Co nebylo dosud popsáno je pouze úkon \textit{registrace do UIO subsystému}.

\ibox{\texttt{int uio\_register\_device(struct device *parent, struct uio\_info *info);}}

Registrace UIO ovladače se provede zavoláním funkce \texttt{uio\_register\_device()}, které se jako první parametr předá ukazatel na \textit{rodiče} struktury \texttt{struct pci\_dev} -- tj. ukazatel na její položku \texttt{dev}. Důvod je ten, že ovladač typu UIO může být vytvořen i pro jiná zařízení než ta na sběrnici PCI.
Druhý parametr předá ukazatel na strukturu \texttt{struct uio\_info}.

\subsubsection{Struktura \texttt{struct uio\_info}}

Jedná se o strukturu vyplněnou informacemi o zařízení, která je předána při registraci UIO subsystému.
Mezi její hlavní položky patří:
\begin{description}
\item[\texttt{const char *name}]~\\Název ovladače. Většinou se shoduje s názvem modulu.
\item[\texttt{const char *version}]~\\Verze ovladače v textové podobě.
\item[\texttt{struct uio\_mem mem[MAX\_UIO\_MAPS]}]~\\Pole struktur obsahujících informace o regionech PCI zařízení mapovaných do paměťového prostoru (bude podrobně vysvětleno dále).
\item[\texttt{struct uio\_port port[MAX\_UIO\_PORT\_REGIONS]}]~\\Pole struktur obsahujících informace o regionech PCI zařízení mapovaných do vstupně-výstupního prostoru (bude podrobně vysvětleno dále).
\end{description}

\subsubsection{Struktura \texttt{struct uio\_mem} a \texttt{struct uio\_port}}\label{uio_mem_port}
Tyto struktury obsahují informace o regionech zařízení. Které (a kolik) z těchto dvou struktur budou inicializovány záleží na tom, zda karta mapuje regiony do paměťového nebo vstupně-výstupního prostoru.

Struktura \texttt{struct uio\_mem} obsahuje položky:
\begin{description}
\item[\texttt{const char *name}]~\\Textový popis daného regionu (viditelný z uživatelského prostoru).
\item[\texttt{unsigned long addr}]~\\Fyzická adresa regionu získaná voláním \texttt{pci\_resource\_start()}.
\item[\texttt{unsigned long size}]~\\Délka regionu. Nejsnáze získaná voláním \texttt{pci\_resource\_len()}.
\item[\texttt{int memtype}]~\\Typ paměti. Pro fyzickou paměť na zařízení se použije \texttt{UIO\_MEM\_PHYS}.
\item[\texttt{void \_\_iomem *internal\_addr}]~\\Virtuální adresa získaná voláním \texttt{pci\_ioremap\_bar()}.
\end{description}

Struktura \texttt{struct uio\_port} obsahuje položky:
\begin{description}
\item[\texttt{const char *name}]~\\Textový popis daného regionu (viditelný z uživatelského prostoru).
\item[\texttt{unsigned long start}]~\\Fyzická adresa regionu získaná voláním \texttt{pci\_resource\_start()}.
\item[\texttt{unsigned long size}]~\\Délka regionu. Nejsnáze získaná voláním \texttt{pci\_resource\_len()}.
\item[\texttt{int porttype}]~\\Typ portu. Pro porty na architektuře IA-32 se použije \texttt{UIO\_PORT\_X86}.
\end{description}

~\\

Příklad, jak taková jednoduchá inicializace struktury \texttt{struct uio\_info} včetně registrace může vypadat (bez ošetření chybových stavů):
\begin{verbatim}
 1 |  /* struct pci_dev *dev */
 2 |  struct uio_info *info;
 3 |  info = kzalloc(sizeof(struct uio_info), GFP_KERNEL);
 4 |  
 5 |  info->name = "mf624";
 6 |  info->version = "0.0.1";
 7 |  
 8 |  info->mem[0].name = "PCI chipset, ...";
 9 |  info->mem[0].addr = pci_resource_start(dev, 0);
10 |  info->mem[0].size = pci_resource_len(dev, 0);
11 |  info->mem[0].memtype = UIO_MEM_PHYS;
12 |  info->mem[0].internal_addr = pci_ioremap_bar(dev, 0);
13 |  
14 |  info->port[0].name = "Board programming registers";
15 |  info->port[0].porttype = UIO_PORT_X86;
16 |  info->port[0].start = pci_resource_start(dev, 1);
17 |  info->port[0].size = pci_resource_len(dev, 1);
18 |  
19 |  uio_register_device(&dev->dev, info);
20 |  pci_set_drvdata(dev, info);
\end{verbatim}

\ibox{\texttt{void pci\_set\_drvdata(struct pci\_dev *pdev, void *data)}}

Na posledním řádku je, dosud nepopsané, volání \texttt{pci\_set\_drvdata()}. To (v tomto případě) zajistí, že struktura \texttt{struct uio\_info} se stane součástí struktury reprezentující zařízení (\texttt{struct pci\_dev}) -- což umožní pozdější přístup ke struktuře \texttt{struct uio\_info} z funkcí jako je například \texttt{remove()}, která jako parametr získá ukazatel na strukturu \texttt{struct pci\_dev}.

\ibox{\texttt{static inline void *pci\_get\_drvdata(struct pci\_dev *pdev)}}

Funkce \texttt{pci\_get\_drvdata()} slouží k \textit{získání} dat uložených do struktury \texttt{struct pci\_dev} pomocí volání \texttt{pci\_set\_drvdata()}.

Příklad použití:
\begin{verbatim}
 1 |  static void mf624_pci_remove(struct pci_dev *dev)
 2 |  {
 3 |      struct uio_info *info = pci_get_drvdata(dev);
 4 |      /* ... */
 5 |  }
\end{verbatim}


\subsection{Program v uživatelském prostoru}
Poté, co je jaderná část UIO ovladače úspěšně zkompilována a zavedena do systému, ve kterém se nachází požadované zařízení, je rozhraní mezi tímto modulem a uživatelským prostorem tvořeno:
\begin{itemize}
\item souborem \texttt{/dev/uio0\footnote{Pro názornost je v textu uvedeno konkrétní zařízení \texttt{uio0}. V případě, že systém obsahuje více aktivních UIO ovladačů, jsou postupně číslovány od 0 výše.}}.
\item složkou \texttt{/sys/class/uio/uio0}, která obsahuje informace o regionech, které jsou zpřístupněny skrze UIO modul v jádře.
\end{itemize}

\subsubsection{Obsah složky \texttt{/sys/class/uio/uio0}}
Tato složka obsahuje soubory převážně pouze pro čtení. Obsahuje podsložku \texttt{maps}, ve které se nachází pro každý region PCI zařízení mapovaný do paměti (zpřístupněný jaderným ovladačem) složka obsahující soubory popisující tyto regiony (Soubor \texttt{addr} obsahuje fyzickou adresu regionu; \texttt{name} slovní pojmenování; \texttt{size} velikost regionu).

V případě, že jsou zpřístupněny regiony zařízení, které jsou mapovány do vstupně-výstupního adresního prostoru, nacházejí se jednotlivé podsložky a soubory popisující regiony ve složce \texttt{portio}.

\subsubsection{Soubor \texttt{/dev/uio0}}
Tento soubor tvoří rozhraní mezi jaderným subsystémem UIO a uživatelským prostorem. Skrze něj je přistupováno k regionům karty. K souboru se přistupuje pomocí volání \texttt{mmap()}.

\ibox{\texttt{void *mmap(void *addr, size\_t length, int prot, int flags, int fd, off\_t offset);}}

Tato funkce slouží k \textit{namapování} souboru nebo zařízení do operační paměti. V případě, že je funkce zavolána na soubor, proběhne-li vše správně, návratová hodnota bude obsahovat ukazatel do paměti, kam je možné přistu\-povat k obsahu souboru pomocí ukazatelové aritmetiky -- stejně, jako by to byla paměť.
 
\begin{description}
\item[Parametr \texttt{addr}]~\\V případě, že není nulový, určí na jakou adresu by měla být paměť mapována.
\item[Parametr \texttt{length}]~\\ Udává velikost mapované paměti v násobcích velikosti paměťové stránky. 
\item[Parametr \texttt{prot}]~\\ Obsahuje příznaky definující, zda bude mapovaná paměť pro čtení/zápis, apod.
\item[Parametr \texttt{flags}]~\\ Pomocí příznaku určuje, zda se mají změny zapisovat pouze do \textit{lokální kopie} (příznak \texttt{MAP\_PRIVATE}) nebo zda mají být zapisovány do původního souboru/zařízení (příznak \texttt{MAP\_SHARED}).
\item[Parametr \texttt{fd}]~\\ Obsahuje \textit{filedescriptor} na zařízení, které má být namapováno (v tomto případě file\-desc\-riptor vrácený voláním \texttt{open("/dev/uio0", ... );}).
\item[Parametr \texttt{offset}]~\\ Určuje, zda se daný soubor/zařízení začne mapovat od posunuté adresy. V případě UIO ovladače je možné jako offset používat násobky velikosti paměťové stránky -- tento offset určí, který z regionů zpřístupněných jadernou částí ovladače má být namapován.
\end{description}

Příklad, jak takové volání může vypadat (bez ošetření chybových stavů):
\begin{verbatim}
 1 |  #define BAR2_offset       (1 * sysconf(_SC_PAGESIZE))
 2 |  
 3 |  void* mf624_BAR2 = NULL;
 4 |  int device_fd = open("/dev/uio0", O_RDWR);
 5 |  
 6 |  mf624_BAR2 = mmap(0, 1 * sysconf(_SC_PAGESIZE), 
 7 |                    PROT_READ | PROT_WRITE, MAP_SHARED, 
 8 |                    device_fd, BAR2_offset);
\end{verbatim}

S adresou vrácenou voláním \texttt{mmap()} však není možné vždy ihned pracovat. Může se stát, že mapovaný region PCI zařízení (reprezentovaný zařízením \texttt{/dev/uio0}, na které je \texttt{mmap()} volán) je menší než je velikost celé stránky, \texttt{mmap()} však vrací ukazatel zarovnaný na velikost stránky. Je tedy potřeba se v rámci této stránky posunout na tu část, která odpovídá požadovanému regionu.

Jak velký je potřeba udělat \textit{posun} pomůže zjistit soubor \texttt{/sys/class/uio/uio0/maps/map1/addr}\footnote{Pro názornost je uvedena konkrétní cesta -- jedná se tedy o \textit{druhý} paměťový region zařízení \textit{uio0}.} -- ten obsahuje fyzickou adresu požadovaného regionu. Z té je možné následujícím trikem získat ukazatel, se kterým je již možné pracovat (nejnižší bity totiž budou zachovány z fyzické adresy):
\begin{verbatim}
mf624_BAR2 += (BAR2_phys_addr & (sysconf(_SC_PAGESIZE) - 1));
  |                \-- Fyzická adresa
   \-- Ukazatel vrácený voláním mmap()                 
\end{verbatim}

\subsection{Přístup k paměti zařízení}
Jelikož se jedná o paměť zařízení, je potřeba i v uživatelském prostoru k této paměti přistupovat pomocí speciálních funkcí. Ty jsou popsány v kapitole \ref{iofce}.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%\newpage
\section{Comedi ovladač}
Kromě popsaných výhod UIO ovladače jsou zde i nevýhody. Jednou z nich je pomalejší odezva než v případě plnohodnotného jaderného ovladače. Další nevýhodou je neexistence knihovny v uživatelském prostoru, která by poskytovala jednotné API pro přístup k zařízení (v případě UIO ovladače je potřeba vytvořit pro každé zařízení specifický program).

Pro ovladače měřících karet (které disponují základními funkcemi) existuje v Linuxu subsystém -- tzv. Comedi (Control and Measurement Device Interface).

Comedi se skládá ze tří částí:

\begin{description}
\item[Comedi] -- jsou jednotlivé nízkoúrovňové ovladače zařízení, včetně hlavního ovladače \texttt{comedi}, který poskytuje základní funkce.
\item[Comedilib] -- je knihovnou v uživatelském prostoru, která poskytuje jednotné rozhraní pro ovládání jednotlivých zařízení. 
\item[Kcomedilib] -- je jaderný modul, který poskytuje stejné rozhraní jako Comedilib v uživatelském prostoru. Používá v případě potřeby ovládat zařízení v reálném čase.
\end{description}


\subsection{Registrace ovladače}
Pro správnou funkci je potřeba, aby byl ovladač ihned po načtení modulu (t.j. v \textit{init} funkci) zaregistrován, jak do PCI subsystému, tak do subsystému Comedi. Registrace mezi PCI zařízení je popsána v kapitole \ref{pci_reg}. Registrace mezi Comedi ovladače se provede voláním \texttt{comedi\_driver\_register(struct comedi\_driver *driver)}, kde jako parametr se předá ukazatel na strukturu \texttt{struct comedi\_driver}.

\subsection{Struktura \texttt{struct comedi\_driver}}
Nejdůležitější položky, které tato struktura obsahuje jsou ukazatele na funkce volané při aktivaci Comedi ovladače.

Položky struktury jsou:
\begin{description}
\item[\texttt{const char *driver\_name;}]~\\Obsahuje textový název ovladače.
\item[\texttt{struct module *module;}]~\\Ukazatel na modul, kterému tato struktura náleží. Inicializuje se makrem \texttt{THIS\_MODULE}.
\item[\texttt{int (*attach) (struct comedi\_device *, struct comedi\_devconfig *);}]~\\Ukazatel na funkci, která má být zavolána při aktivaci ovladače.
\item[\texttt{int (*detach) (struct comedi\_device *);}]~\\Ukazatel na funkci, která má být zavolána při deaktivaci ovladače.
\end{description}

Narozdíl od předchozích příkladů je v tomto případě tou hlavní \textit{inicializační} funkcí nikoliv funkce \texttt{probe()} volaná PCI subsystémem v případě, že se v systému nachází hardware, který umí ovladač obsloužit, ale funkce \texttt{attach()}, která je volána Comedi subsystémem v závislosti na tom, zda má být ovladač použit nebo ne.

\subsection{Funkce \texttt{attach}}
Funkce \texttt{attach} je volána v případě aktivace Comedi ovladače. Dříve než dojde na popis inicializačních kroků je nutné vysvětlit názvosloví, které je u Comedi ovladačů používáno.

\begin{description}
\item[Board] označuje konkrétní zařízení -- měřící kartu. Některé ovladače podporují celou sadu zařízení (např. od stejného výrobce).
\item[Subdevice (\textit{podzažízení})] je jedna z mnoha funkcí zařízení. V případě ovladače karty Humusoft MF614 budou implementovány 4 podzařízení: digitální vstupy, digitální výstupy, analogové vstupy, analogové výstupy.
\end{description}

Kromě obvyklých operací, jako je \textit{aktivace zařízení}, žádos o \textit{výhradní přístup} ke zdrojům zařízení a \textit{mapování} paměťových nebo I/O regionů, popsaných v kapitole \ref{pci_driv}, je nutné alokovat a inicializovat struktury \texttt{struct comedi\_subdevice}.

\subsection{Struktura \texttt{struct comedi\_subdevice}}
Každé podporované funcki zařízení/karty by měla odpovídat jedna struktura \texttt{struct comedi\_subdevice}. Hlavní položky, které struktura obsahuje:

\begin{description}
\item[\texttt{int type}]~\\ Označuje druh \textit{podzařízení}. Na výběr jsou např. možnosti: 
\texttt{COMEDI\_SUBD\_AI} (analogový vstup), \texttt{COMEDI\_SUBD\_AO} (analogový výstup), \texttt{COMEDI\_SUBD\_DI} (digitální vstup), \texttt{COMEDI\_SUBD\_DO} (digitální výstup).

\item[\texttt{int subdev\_flags}]~\\ Označuje základní vlastnost podzařízení. Nejpoužívanější hodnoty: \texttt{SDF\_READABLE} (z podzařízení může být čteno), \texttt{SDF\_WRITABLE} (do podzařízení může být zapisováno).

\item[\texttt{int n\_chan}]~\\ Počet kanálů podzařízení (např. pro 8 digitálních vstupů bude tato hodnota 8).

\item[\texttt{unsigned int maxdata}]~\\ Maximální hodnota, která může být do podzařízení zapsána/čtena.
\item[\texttt{const struct comedi\_lrange *range\_table}]~\\Označuje rozsah, ve kterém dané podzařízení měří (např. u A/D převodníku 0--10 V). K dispozici jsou definované struktury (staří pouze předat jejich ukazatel):\\
\texttt{range\_digital},\\ \texttt{range\_bipolar10},\\ \texttt{range\_bipolar5},\\ \texttt{range\_unipolar10},\\ \texttt{range\_unipolar5}.\\ Jejich názvy jsou samovysvětlující.

\item[\texttt{int (*insn\_read) ( ... );}]~\\Ukazatel na funkci, která má na starosti čtení z podzařízení (většinou se používá pro A/D převodníky).
\item[\texttt{int (*insn\_write) ( ... );}]~\\Ukazatel na funkci, která má na starosti zápis do zařízení (většinou se používá pro A/D převodníky).
\item[\texttt{int (*insn\_bits) ( ... );}]~\\Ukazatel na funkci použitou pro zápis a čtení digitálních výstupů a vstupů,
\item[\texttt{int (*insn\_config) ( ... );}]~\\Ukazatel na funkci, která má na starosti konfiguraci podazařízení.

Poslední čtyři funkce mají parametry: \\ \texttt{(struct comedi\_device *, struct comedi\_subdevice *, struct comedi\_insn *, unsigned int *);}. První z nich je ukazatel na strukturu popisující Comedi ovladač. Druhý je ukazatelem na strukturu odpovídající podzařízení. Třetí obsahuje ukazatel na strukturu popisující \textit{instrukci}, která má být provedena. Poslední obsahuje ukazatel na proměnnou, ze které je vyčtena zapisovaná hodnota nebo je do ni čtená hodnota zapsána.
 
\end{description}

\ibox{\texttt{int alloc\_subdevices(struct comedi\_device *dev, unsigned int num\_subdevices)}}

Alokace paměti pro struktury se provede voláním \texttt{alloc\_subdevices()}, které je poskytováno Comedi subsystémem. Prvním parametrem je předán ukazatel na strukturu \texttt{struct comedi\_device}, pro kterou má být alokace provedena. Alokovaná paměť je přístupná skrze proměnnou \texttt{subdevices} náležící struktuře \texttt{struct comedi\_device}. 

V případě dealokace zdrojů ovladače není potřeba tuto paměť dealokovat -- o uvolnění paměti se postará Comedi subsystém. 

\subsection{Funkce pro čtení a zápis z/do podzařízení}
Funkce pro čtení, zápis a konfiguraci A/D, D/A převodníků a digitálních vstupů a výstupů mají stejné parametry. Jsou to: \texttt{(struct comedi\_device *dev, 
struct comedi\_sub- device *s, struct comedi\_insn *insn, unsigned int *data)};

V prvním parametru je předán ukazatel na strukturu reprezentující Comedi zařízení. Díky tomu je možné prostřednictvím její proměnné \texttt{private} získat ukazatel na strukturu obsahující privátní data ovladače.

Druhý parametr je ukazatel na strukturu reprezentující podzařízení. Tato struktura obsahuje, kromě položek inicializovaných ve funkci \textit{attach} i proměnnou \texttt{state}. Tato proměnná popisuje \textit{stav zařízení} a používá se především pro zjištění stavu digitálních výstupů (stav digitálních výstupů není možné za zařízení přečíst, pro změnu pouze jednoho bitu je tedy potřeba znát stav ostatních).

Třetí parametr obsahuje ukazatel na strukturu popisující danou \textit{instrukci}, která má být provedena. Důležité položky, které tato struktura obsahuje:
\begin{description}
\item[\texttt{unsigned int n}]~\\Udává počet instrukcí, které mají být provedeny
\item[\texttt{unsigned int chanspec}]~\\Obsahuje informace o kanálu podzařízení, na kterém má být operace provedena. V jedné proměnné typu \texttt{unsigned int} je obsaženo více údajů, proto je potřeba ke čtení používat speciální makro
\texttt{CR\_CHAN()}, které vrací číslo zvoleného kanálu.
\end{description}


\subsection{Funkce \texttt{detach}}
Tato funkce je volána jak v případě ukončení funkce ovladače, tak v případě, že funkce \textit{attach} neproběhla v pořádku. Proto je potřeba rozlišit, které zdroje ovladače již byly úspěšně naalokovány a mají být uvolněny.

Odregistrování ovladače z PCI a Comedi subsystému by mělo být voláno v \textit{úklidové funkci} modulu. O samotné odregistrování se starají funkce:
\texttt{pci\_unregister\_driver()} a \texttt{comedi\_driver\_unregister()}, kterým se jako parametr předá ukazatel na strukturu použitou při registraci.


\subsection{Přístup z uživatelského prostoru}
Pro správnou funkci konkrétního Comedi ovladače je nejprve potřeba načíst modul Comedi (\texttt{modprobe comedi}). Poté je již možné načíst ovladač zařízení (v případě ručně kompilovaného ovladače, pomocí příkazu \texttt{insmod}, jinak opět pomocí \texttt{modprobe}).

V případě, že proběhlo načtení modulu a spuštění funkce \textit{attach} bez problémů, měl by se ve složce \texttt{/dev} objevit nový soubor odpovídající načtenému ovladači zařízení -- comedi0\footnote{Pro názornost je uveden konkrétní příklad, v případě načtení více ovladačů budou odpovídající soubory číslovány od 0 výše.} K tomuto souboru je poté možné pomocí knihovních funkcí Comedilib přistupovat.

Pro přístup k zařízení je potřeba zavolat na soubor \texttt{/dev/comedi0} funkci \texttt{comedi\_open()}. Ta vrací ukazatel datového typu \texttt{comedi\_t}, reprezentujícího dané zařízení. K němu je možné přistupovat pomocí funkcí\\
\texttt{comedi\_data\_read()},\\
\texttt{comedi\_data\_write()},\\
\texttt{comedi\_dio\_read()},\\
\texttt{comedi\_dio\_write()}.

První dvě slouží pro zápis/čtení A/D a D/A převodníků, zatímco poslední dvě slouží pro přístup k digitálním vstupům/výstupům.
Prvním parametrem všech funkcí je ukazatel na \texttt{comedi\_t}. Druhým je číslo \textit{podzařízení}. Třetí parametr určuje kanál (t.j. např. který z osmi A/D převodníků má být čten). Posledním parametrem je ukazatel na proměnnou, kam mají být zapsána přečtena data nebo hodnota, která má být zapsána.

Ukázka jednoduchého userspace programu:
\begin{verbatim}
  1 |  #include <stdio.h>
  2 |  #include <comedilib.h>
  3 |  #define MF614_DO_SUBDEV      1 /* Je potřeba vědět, jak je 
  4 |                                    implementováno v ovladači */
  5 |  
  6 |  int main(int argc, char* argv[])
  7 |  {
  8 |      comedi_t* comedi_dev;
  9 |  
 10 |      comedi_dev = comedi_open("/dev/comedi0");
 11 |      if (comedi_dev == NULL) {
 12 |          comedi_perror("comedi_open");
 13 |          return 1;
 14 |      }
 15 |
 16 |      /* Zápis 1 na 0. kanál digitálního výstupu */  
 17 |      comedi_dio_write(comedi_dev, MF614_DO_SUBDEV, 0, 1);
 18 |      sleep(1);
 19 |      comedi_dio_write(comedi_dev, MF614_DO_SUBDEV, 0, 0);
 20 |      sleep(1);
 21 |      comedi_dio_write(comedi_dev, MF614_DO_SUBDEV, 0, 1);
 22 |      
 23 |      return 0;
 24 |  }
\end{verbatim}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Implementace karty Humusoft MF624 v Qemu}\label{qemu}
Měřící karta Humusoft MF624 je hardware vhodný pro výklad principů implementace ovladačů. Nevýhodou může být její cena. Pro účely výuky proto byly do emulačního software Qemu implementovány základní funkce této měřící karty -- konkrétně se jedná o A/D převodníky, D/A převodníky a digitální vstupy a výstupy. Takto modifikovaná verze qemu může pří implementaci základního ovladače plně nahradit původní kartu.

Kromě částečné implementace karty MF624 do Qemu je součástí tohoto \textit{virtuálního hardware} grafická aplikace, která má na starosti nastavování vstupních hodnot a zobrazování výstupních hodnot do/z karty.


\section{Qemu}
Qemu je emulátor různých procesorových architektur. Od klasických virtualizačních nás\-tro\-jů se odlišuje tím, že podporuje velké kromě IA-32 architektury také např. ARM, SPARC, PowerPC, MIPS, m68k. Qemu umožňuje kromě \textit{plné emulace} (kdy je spuštěn celý operační systém) tzv. \textit{uživatelskou emulaci}, kdy je v uživatelském prostoru spuštěn program zkompilovaný pro jinou architekturu. Uživatelská emulace je možná pouze pro operační systém GNU/Linux.

\subsection{Kompilace, instalace}
Po stažení a rozbalení zdrojových kódů některé ze stabilních verzí emulátoru Qemu je potřeba spustit příkaz (na počítači architektury AI-32):
\begin{verbatim}
    $ ./configure --enable-system  --target-list=i386-softmmu
\end{verbatim}

V případě, že spuštěný skript neohlásí žádné chybějící knihovny, je možné spustit  samotnou kompilaci:
\begin{verbatim}
    $ make
\end{verbatim}

\subsection{Kompilace virtuální karty Humusoft MF624}
V případě, že je potřeba zkompilovat virtuální kartu MF624, je potřeba  před kompilací překopírovat zdrojový soubor implementující zařízení do složky \texttt{/hw} a do souboru \texttt{Makefile.objs} (nachází se v kořenovém adresáři se zdrojovými kódy) přidat řádek \begin{verbatim}
    hw-obj-$(CONFIG_PCI) += mf624.o
\end{verbatim}
Poté je již možné spustit příkaz
\begin{verbatim}
    $ make
\end{verbatim}


\subsection{Použití}
Zkompilovaný binární soubor se nachází v adresáři \texttt{i386-softmmu}. Nejnutnější parametr při spuštění je \texttt{-hda}, který uvádí cestu k souboru reprezentující \textit{obraz} spouštěného systému.

V případě správně zkompilované virtuální karty MF624, je možné ji spustit zadáním parametru \texttt{-device mf624}. Po spuštění je v příkazové řádce vypsáno číslo TCP/IP portu, na kterém virtuální karta MF614 naslouchá. Tento port slouží k připojení klientského programu, který má na starosti vykreslování výstupních a nastavování vstupních hodnot karty (možná implementace je popsána v kapitole \ref{qt_gui_ch}. V případě neexistence klientského software je možné se připojit pomocí programu \texttt{telnet}.

Příklad spuštění:
\begin{verbatim}
    $ ./qemu -device mf624 -hda ../os_images/debian.qcow --boot c 
    MF624 Loaded.
    Waiting on port 55555 for MF624 client to connect
    Client connected
\end{verbatim}

\section{Qt grafiké rozhraní}\label{qt_gui_ch}
Pro komunikaci s virtuální kartou MF624 bylo implementováno jednoduché grafické rozhraní, které má na starosti vykreslování hodnot výstupů karty (nastavovaných ovladačem běžícím v operačním systému virtualizovaném Qemu) a posílání nastavovaných vstupních hodnot zpět virtuální kartě.

Komunikace mezi virtuální kartou a grafickou aplikací probíhá pomocí TCP/IP protokolu. Přenášené informace jseou textového charakteru, ve formátu \texttt{REGISTR=HODNOTA}.

Na obrázku \ref{qt_gui} je vidět vzhled grafické aplikace.

\subsection{Kompilace, použití}
Grafická aplikace je vytvořena za pomoci grafického knihovny Qt. V případě, že jsou v systému nainstalovány vývojářské verze Qt knihoven, včetně vývojářských nástrojů, stačí pro kompilaci spustit
\begin{verbatim}
    $ qmake
    $ make
\end{verbatim}

Použití aplikace by mělo být intuitivní. Položky, u kterých není možné měnit jejich hodnotu jsou záměrně pouze pro čtení.


\begin{figure}[h!]
        \begin{center}
        \includegraphics[width=90mm]{img/qt_gui.png}
        \caption{(FIXME aktualni verzi). Vzhled grafické aplikace pro ovládání vstupů a výstupů virtuální karty MF624}
        \label{qt_gui}
        \end{center}
\end{figure}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Testování}
\section{UIO ovladač, Comedi ovladač}
Jednotlivé ovladače jsou tvořeny samostatnými jadernými moduly, které pouze využívají volání jednotlivých subsystémů -- neexportují žádné \textit{symboly} ani nemění globální proměnné. V tomto případě nebylo nutné provádět regresní testování.

Testování správnosti funkce ovladačů probíhala přímo na hardware, za pomoci \textit{univerzální svorkovnice TB620} (obrázek \ref{svorkovnice}).

\begin{figure}[h!]
        \begin{center}
        \includegraphics[width=120mm]{img/svorkovnice.jpg}
        \caption{Svorkovnice TB620}
        \label{svorkovnice}
        \end{center}
\end{figure}

\vspace{1cm}
Základní propojení na svorkovnici, které se osvědčilo, bylo:
\begin{itemize}
\item 2 $\times$ LED pro nejnižší a nejvyšší bit DOUT
\item 2 $\times$ 1k$\Omega$ rezistory mezi 5 V a nejnižším a nejvyšším bitem DIN
\item 2. bit DIN dynamicky spojován s GND nebo pomocí 1k$\Omega$ rezistoru s 5 V
\item Měření multimetrem výstupní hodnoty z DAC (většinou DAC0 nebo DAC1)
\item ADC0 spojen s GND, ADC1 spojen pomocí 1k$\Omega$ rezistoru s DAC0
\end{itemize}

~\\

Konzistence jádra byla testována opětovným načítáním a uvolňováním jednotlivých ovladačů.

\section{Qemu virtuální hardware, Qt grafické rozhraní}
Správnost implementace virtuálního hardware byla testována spouštěním implementovaných ovladačů v systému virtualizovaného v Qemu. Zároveň byla ověřena funkčnost grafického rozhraní, reprezentujícího vstupy a výstupy do/z virtuální karty. 


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Závěr}
V této práci se mi podařilo vysvětlit základní aspekty psaní ovladačů PCI ovladačů pro operační systém GNU/Linux -- jak na obecné úrovni, tak u konkrétních ovladačů typu UIO a Comedi.

Součástí práce jsou základní (pokrývající pouze A/D, D/A převodníky a digitální vstupy/výstupy) ovladače pro karty Humusoft MF624 a Humusoft MF614. V budoucnu by tyto ovladače mohly být rozšířeny tak, aby pokrývaly všechny funkce těchto karet.

Pro potřeby výuky byly implementovány základní funkce karty Humusoft MF614 do emulátoru Qemu. Tato implementace by mohla být v budoucnu rozšířena, případně by mohla posloužit jako příklad pro implementaci jiných jednoduchých PCI zařízení sloužících pro výuku implementace PCI ovladačů. I když tak nebylo původně zamýšleno, mohla by částečná implementace karty MF614 do Qemu posloužit i při výuce psaní ovladačů pro jiné operační systémy, jako například systémy rodiny Microsoft Windows.


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%\appendix
%\chapter{Hudaqlib}

%\chapter{Obsah přiloženého CD}