source: trunk/kernel/kern/chdev.h @ 602

Last change on this file since 602 was 564, checked in by alain, 6 years ago

Complete restructuration of kernel locks.
File size: 14.0 KB
RevLine 
[5]1/*
2 * chdev.h - channel device (chdev) descriptor definition.
3 *
4 * Authors  Alain Greiner    (2016)
5 *
6 * Copyright (c) UPMC Sorbonne Universites
7 *
8 * This file is part of ALMOS-MKH
9 *
10 * ALMOS-MKH is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2.0 of the License.
13 *
14 * ALMOS-MKH is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24#ifndef _CHDEV_H_
25#define _CHDEV_H_
26
[14]27#include <kernel_config.h>
[457]28#include <hal_kernel_types.h>
[5]29#include <xlist.h>
[564]30#include <remote_busylock.h>
[346]31#include <dev_iob.h>
[5]32#include <dev_ioc.h>
33#include <dev_nic.h>
34#include <dev_pic.h>
35#include <dev_fbf.h>
[428]36#include <dev_txt.h>
[5]37
38/******************************************************************************************
39 *       Channel Device descriptor definition
40 *
41 * This file defines the kernel representation of a generic (i.e. implementation
42 * independant) Channel Device descriptor (in brief "chdev").
[23]43 * ALMOS-MKH supports multi-channels peripherals, and defines one separated chdev
[440]44 * descriptor for each channel (and for each RX/TX direction for the NIC and TXT devices).
[564]45 * Each chdev contains a trans-clusters waiting queue, registering the "client threads",
[5]46 * and an associated "server thread", handling these requests.
47 * These descriptors are physically distributed on all clusters to minimize contention.
48 * Therefore a given I/O operation involve generally three clusters:
49 * - the client cluster, containing the client thread,
[204]50 * - the server cluster, containing the chdev and the server thread,
51 * - the I/O cluster, containing the physical device.
[5]52 *****************************************************************************************/
53
54/****  Forward declarations  ****/
55
56struct  chdev_s;
57struct  thread_s;
58struct  boot_info_s;
59
60/******************************************************************************************
61 * These macros extract the functionality and the implementation from the peripheral type.
62 *****************************************************************************************/
63 
64#define FUNC_FROM_TYPE( type )    ((uint32_t)(type>>16))
65#define IMPL_FROM_TYPE( type )    ((uint32_t)(type & 0x0000FFFF))
66
67/******************************************************************************************
[407]68 * This define the generic prototypes for the three functions that must be defined
69 * by the drivers implementing a generic device:
70 * - "cmd"     : start a blocking I/O operation.
[5]71 * - "isr"     : complete an I/O operation.
[407]72 * - "aux"     : not for all drivers (implement special functions)
73 * The "cmd", "isr", and "aux" driver functions are registered in the generic chdev
74 * descriptor at kernel init, and are called to start and complete an I/O operation. 
[5]75*****************************************************************************************/
76
77typedef void (dev_ini_t) ( xptr_t dev );     
78typedef void (dev_cmd_t) ( xptr_t thread ); 
79typedef void (dev_isr_t) ( struct chdev_s * dev ); 
[407]80typedef void (dev_aux_t) ( void * args ); 
[5]81
82/******************************************************************************************
83 * This enum defines the supported generic device types.
84 * These types are functionnal types: all (architecture specific) implementations
85 * provide the same set of operations and the same driver API.
86 * This enum must be consistent with the enum in files arch_info.h, and arch_class.py.
[204]87 *
88 * WARNING : The ICU device exist in boot_info to specify the base address of the
89 *           distributed LAPIC controler, but it does not exist as a chdev in the kernel,
90 *           as it is hidden in the driver associated to the PIC device.
[5]91 *****************************************************************************************/
92 
93enum dev_func_type
94{
95        DEV_FUNC_RAM   =  0,
96        DEV_FUNC_ROM   =  1,
97        DEV_FUNC_FBF   =  2,
98    DEV_FUNC_IOB   =  3,
99    DEV_FUNC_IOC   =  4,
100        DEV_FUNC_MMC   =  5,
101        DEV_FUNC_DMA   =  6,
102        DEV_FUNC_NIC   =  7,
103        DEV_FUNC_TIM   =  8,
104        DEV_FUNC_TXT   =  9,
[204]105    DEV_FUNC_ICU   = 10,   
[5]106    DEV_FUNC_PIC   = 11,
107
108    DEV_FUNC_NR    = 12,
109};
110
111/******************************************************************************************
112 * This structure defines a chdev descriptor.
[23]113 * For multi-channels device, there is one chdev descriptor per channel.
[5]114 * This structure is NOT replicated, and can be located in any cluster.
115 * One kernel thread, in charge of handling the commands registered in the waiting queue
116 * of client threads is associated to each chdev descriptor (not for ICU, PIC, IOB).
[428]117 * For each device type ***, the specific extension is defined in the "dev_***.h" file.
[564]118 *
119 * NOTE : For most chdevs, the busylock is used to protect the waiting queue changes,
120 *        when a thread register in this queue, or is removed after service.
121 *        This busylock is also used to protect direct access to the kernel TXT0 terminal
122 *        (without using the server thread).
[5]123 *****************************************************************************************/
124
125typedef struct chdev_s
126{
127        uint32_t             func;        /*! peripheral functionnal type                    */
128        uint32_t             impl;        /*! peripheral inplementation subtype              */
129    uint32_t             channel;     /*! channel index                                  */
[407]130    bool_t               is_rx;       /*! relevant for NIC and TXT peripherals           */
[188]131        xptr_t               base;        /*! extended pointer on channel device segment     */
[23]132    char                 name[16];    /*! name (required by DEVFS)                       */
[5]133
[407]134    dev_cmd_t          * cmd;         /*! local pointer on driver CMD function           */
135    dev_isr_t          * isr;         /*! local pointer on driver ISR function           */
136    dev_aux_t          * aux;         /*! local pointer on driver AUX function           */
137
[5]138    struct thread_s    * server;      /*! local pointer on associated server thread      */
139
140    uint32_t             irq_type;    /*! associated IRQ type in local ICU               */
141    uint32_t             irq_id;      /*! associated IRQ index in local ICU              */
142
[564]143        xlist_entry_t        wait_root;   /*! root of client threads waiting queue           */
144    remote_busylock_t    wait_lock;   /*! lock protecting waiting queue                  */
[5]145
146    union
147    {
[346]148        iob_extend_t     iob;         /*! IOB specific extension                         */
[5]149        ioc_extend_t     ioc;         /*! IOC specific extension                         */
150        nic_extend_t     nic;         /*! NIC specific extension                         */
151        pic_extend_t     pic;         /*! PIC specific extension                         */
152        fbf_extend_t     fbf;         /*! FBF specific extension                         */
[428]153        txt_extend_t     txt;         /*! TXT specific extension                         */
[5]154    } 
155    ext;
156}
157chdev_t;
158
159/******************************************************************************************
160 * This structure defines the channel_devices descriptors directory.
161 * Each entry in this structure contains an extended pointer on a chdev descriptor.
162 * There is one entry per channel OR per cluster, depending on peripheral type.
163 * This structure is replicated in each cluster, and is initialised during kernel init.
164 * It is used for fast access to a device descriptor, from type and channel for an
[450]165 * external peripheral, or from type and cluster for an internal peripheral.
[5]166 * - a "shared" chdev can be accessed by any thread running in any cluster.
167 * - a "private" chdev can only be accessed by a thread running in local cluster.
168 *****************************************************************************************/
169
170typedef struct chdev_directory_s
171{
172    xptr_t   iob;                                // external / single channel / shared
173    xptr_t   pic;                                // external / single channel / shared
174
175    xptr_t   ioc[CONFIG_MAX_IOC_CHANNELS];       // external / multi-channels / shared
176    xptr_t   fbf[CONFIG_MAX_FBF_CHANNELS];       // external / multi-channels / shared
[407]177    xptr_t   txt_rx[CONFIG_MAX_TXT_CHANNELS];    // external / multi-channels / shared
178    xptr_t   txt_tx[CONFIG_MAX_TXT_CHANNELS];    // external / multi-channels / shared
[5]179    xptr_t   nic_rx[CONFIG_MAX_NIC_CHANNELS];    // external / multi-channels / shared
180    xptr_t   nic_tx[CONFIG_MAX_NIC_CHANNELS];    // external / multi-channels / shared
181
182    xptr_t   mmc[CONFIG_MAX_CLUSTERS];           // internal / single channel / shared
183
184    xptr_t   dma[CONFIG_MAX_DMA_CHANNELS];       // internal / multi-channels / private
185}
186chdev_directory_t;
187
188/******************************************************************************************
189 * This function display relevant values for a chdev descriptor.
190 ******************************************************************************************
191 * @ chdev   : pointer on chdev.
192 *****************************************************************************************/
193void chdev_print( chdev_t * chdev );
194
195/******************************************************************************************
196 * This function returns a printable string for a device functionnal types.
197 ******************************************************************************************
198 * @ func_type  : functionnal type.
[16]199 * @ return pointer on string.
[5]200 *****************************************************************************************/
201char * chdev_func_str( uint32_t func_type );
202
203/******************************************************************************************
204 * This  function allocates memory and initializes a chdev descriptor in local cluster,
205 * from arguments values.  It should be called by a local thread.
206 * The device specific fields are initialised later.
207 ******************************************************************************************
208 * @ func      : functionnal type.
209 * @ impl      : implementation type.
210 * @ channel   : channel index / for multi-channels peripherals.
211 * @ is_rx     : for NIC peripheral / NIC RX if true / NIC TX if false.
212 * @ base      : extended pointer on peripheral segment base.
213 * @ return a local pointer on created chdev / return NULL if failure.
214 *****************************************************************************************/
215chdev_t * chdev_create( uint32_t    func,
216                        uint32_t    impl,
217                        uint32_t    channel,
218                        bool_t      is_rx,
219                        xptr_t      base );
220
221/******************************************************************************************
[407]222 * This function registers the calling thread in the waiting queue of a remote
[5]223 * chdev descriptor, activates (i.e. unblock) the server thread associated to chdev,
224 * and blocks itself on the THREAD_BLOCKED_IO condition.
225 ******************************************************************************************
226 * @ chdev_xp  : extended pointer on remote chdev descriptor.
227 *****************************************************************************************/
[407]228void chdev_register_command( xptr_t chdev_xp );
[5]229
230/******************************************************************************************
231 * This function is executed by the server thread associated to a chdev descriptor.
232 * It executes an infinite loop to handle sequencially all commands registered by the
233 * client threads in the device waiting queue, until the queue is empty.
234 * The driver CMD function being blocking, these functions return only when the command
235 * is completed. These functions can use either a busy waiting policy, or a descheduling
236 * policy, blocking on the THREAD_BLOCKED_IO_ISR condition, and reactivated by the ISR.
237 * When the waiting queue is empty, the server thread blocks on the THREAD_BLOCKED_IO_CMD
238 * condition and deschedule. It is re-activated by a client thread registering a command.
239 ******************************************************************************************
240 * @ chdev   : local pointer on device descriptor.
241 *****************************************************************************************/
242void chdev_sequencial_server( chdev_t * chdev );
243
[317]244/******************************************************************************************
[428]245 * This function returns an extended pointer on the chdev associated to a pseudo file
246 * descriptor (type INODE_TYPE_DEV) identified by the <file_xp> argument.
247 * It can be called by a thread running in any cluster.
248 * It enters kernel panic if the inode has not the expected type.
249 ******************************************************************************************
250 * @ file_xp   : extended pointer on the pseudo file descriptor.
251 * @ return an extended pointer on chdev.
252 *****************************************************************************************/
253xptr_t chdev_from_file( xptr_t file_xp );
254
255/******************************************************************************************
[317]256 * This function displays the local copy of the external chdevs directory.
257 * (global variable replicated in all clusters)
258 *****************************************************************************************/
[485]259void chdev_dir_display( void );
[5]260
[447]261/******************************************************************************************
262 * This function displays the list of threads registered in the queue associated
263 * to the chdev identified by the <chdev_xp>.
264 ******************************************************************************************
265 * # root_xp  : extended pointer
266 *****************************************************************************************/
267void chdev_queue_display( xptr_t chdev_xp );
268
[5]269#endif  /* _CHDEV_H_ */
Note: See TracBrowser for help on using the repository browser.