[FE training-materials-updates] kernel: introduce devm_ functions earlier

[Michael Opdenacker]

Repository : git://git.free-electrons.com/training-materials.git
On branch  : master
Link       : http://git.free-electrons.com/training-materials/commit/?id=5a360f1b5c54f9f20240d1ffdf87a863dba35e58

>---------------------------------------------------------------

commit 5a360f1b5c54f9f20240d1ffdf87a863dba35e58
Author: Michael Opdenacker <michael.opdenacker at free-electrons.com>
Date:   Tue Nov 29 18:48:10 2016 +0100

    kernel: introduce devm_ functions earlier
    
    - Was needed earlier in the labs anyway
    
    Signed-off-by: Michael Opdenacker <michael.opdenacker at free-electrons.com>


>---------------------------------------------------------------

5a360f1b5c54f9f20240d1ffdf87a863dba35e58
 .../kernel-driver-development-memory.tex           | 16 ++++-----
 slides/kernel-frameworks2/kernel-frameworks2.tex   | 39 ++++++++++++++++++++++
 slides/kernel-input/kernel-input.tex               | 25 +++++---------
 3 files changed, 54 insertions(+), 26 deletions(-)

diff --git a/slides/kernel-driver-development-memory/kernel-driver-development-memory.tex b/slides/kernel-driver-development-memory/kernel-driver-development-memory.tex
index 3aed854..c5e431c 100644
--- a/slides/kernel-driver-development-memory/kernel-driver-development-memory.tex
+++ b/slides/kernel-driver-development-memory/kernel-driver-development-memory.tex
@@ -324,23 +324,19 @@ kfree(work);
   \end{itemize}
 \end{frame}
 
-\begin{frame}[fragile]
+\begin{frame}
   \frametitle{devm\_ kmalloc functions}
-  \footnotesize
+  Allocations with automatic freeing when the corresponding device or module is unprobed.
   \begin{itemize}
-  \item Automatically free the allocated buffers when the
-        corresponding device or module is unprobed.
-  \item Need to have a reference to a \kstruct{device}.
+  \scriptsize
   \item \mint{c}+void *devm_kmalloc(struct device *dev, size_t size, int flags);+
   \item \mint{c}+void *devm_kzalloc(struct device *dev, size_t size, int flags);+
   \item \mint{c}+void *devm_kcalloc(struct device *dev, size_t n, size_t size, gfp_t flags);+
   \item \mint{c}+void *devm_kfree(struct device *dev, void *p);+
-        \begin{itemize}
-        \item Useful to immediately free an allocated buffer
-        \end{itemize}
+        Useful to immediately free an allocated buffer
   \end{itemize}
-  See \kerneldoc{driver-model/devres.txt} for details about managed
-  device resources.
+  \normalsize
+  For use in \code{probe()} functions.
 \end{frame}
 
 \begin{frame}[fragile]
diff --git a/slides/kernel-frameworks2/kernel-frameworks2.tex b/slides/kernel-frameworks2/kernel-frameworks2.tex
index ff29e25..902f733 100644
--- a/slides/kernel-frameworks2/kernel-frameworks2.tex
+++ b/slides/kernel-frameworks2/kernel-frameworks2.tex
@@ -492,6 +492,45 @@ static int serial_imx_remove(struct platform_device *pdev)
   \end{columns}
 \end{frame}
 
+\begin{frame}
+  \frametitle{Device Model: per device allocations (1)}
+  \begin{itemize}
+  \item With the Device Model, structures need to be allocated
+  {\bf for each new device}.
+  \item Such structures then need to be released:
+  \begin{itemize}
+	\item When the module is removed,
+	\item When devices are removed (on a bus
+ 	      which can detect this),
+	\item In the \code{probe()} routine, before
+	      returning after a failure.
+  \end{itemize}
+  \end{itemize}
+\end{frame}
+
+\begin{frame}
+  \frametitle{Device Model: per device allocations (2)}
+  \code{devm_()} functions have been introduced
+  to help managing such allocations.
+  \begin{itemize}
+  \item They now exist in many parts of the kernel
+  \item Allocations are now attached to a \code{struct device}
+	structure.
+  \item Example: call to \kfunc{devm_kzalloc} in the
+	previous example.
+  \item Before each device is destroyed, the resources attached to it
+        are automatically freed. This is not limited to memory
+	allocation. This can also apply to registration of interrupts,
+        for example.
+  \item This greatly simplifies \code{remove()} functions and
+	error management code.
+  \item We will see many \code{devm_} functions in the subsystems
+	that we will study.
+  \end{itemize}
+  See \kerneldoc{driver-model/devres.txt} for implementation details
+  and available functions.
+\end{frame}
+
 \begin{frame}[fragile]
   \frametitle{Link Between Structures 3/4}
   \begin{columns}
diff --git a/slides/kernel-input/kernel-input.tex b/slides/kernel-input/kernel-input.tex
index 1cf1efd..6d8faf9 100644
--- a/slides/kernel-input/kernel-input.tex
+++ b/slides/kernel-input/kernel-input.tex
@@ -57,11 +57,10 @@
 \end{frame}
 
 \begin{frame}[fragile]{Input subsystem API 1/3}
-  \begin{itemize}
-  \item An {\em input device} is described by a very long
-    \kstruct{input_dev} structure, an excerpt is:
-    \begin{block}{}
-    \begin{minted}[fontsize=\tiny]{c}
+  An {\em input device} is described by a very long
+  \kstruct{input_dev} structure, an excerpt is:
+  \begin{block}{}
+  \begin{minted}[fontsize=\tiny]{c}
 struct input_dev {
     const char *name;
     [...]
@@ -79,11 +78,9 @@ struct input_dev {
 };
 \end{minted}
 \end{block}
-\item Before being used this struct must be allocated and initialized:
-  \code{struct input_dev *input_allocate_device(void);}
-\item After unregistering \kstruct{input_dev}, it must be freed:
-  \code{void input_free_device(struct input_dev *dev);}
-  \end{itemize}
+  Before being used it, this structure must be allocated and
+  initialized, typically with:
+  \code{struct input_dev *devm_input_allocate_device(struct device *dev);}
 \end{frame}
 
 \begin{frame}[fragile]{Input subsystem API 2/3}
@@ -157,12 +154,8 @@ struct input_polled_dev {
 
 \begin{frame}[fragile]{Polled input subsystem API}
   \begin{itemize}
-  \item Allocating/freeing the \kstruct{input_polled_dev} structure is
-    done using
-    \begin{itemize}
-    \item \kfunc{input_allocate_polled_device}
-    \item \kfunc{input_free_polled_device}
-    \end{itemize}
+  \item Allocating the \kstruct{input_polled_dev} structure is
+    done using \kfunc{devm_input_allocate_polled_device}
   \item Among the handlers of the \kstruct{input_polled_dev} only the
     \code{poll()} method is mandatory, this function polls the device
     and posts input events.