TOPPERS C++ APIテンプレートライブラリ: toppers/interrupt.hpp Source File

00001 /*
00002  *  TOPPERS/C++ API Template Library
00003  *      Toyohashi Open Platform for Embedded Real-Time Systems/
00004  *      C++ API Template Library
00005  *
00006  *  Copyright (C) 2004 by TAKAGI Nobuhisa
00007  *
00008  *  上記著作権者は，以下の (1)～(4) の条件か，Free Software Foundation
00009  *  によって公表されている GNU General Public License の Version 2 に記
00010  *  述されている条件を満たす場合に限り，本ソフトウェア（本ソフトウェア
00011  *  を改変したものを含む．以下同じ）を使用・複製・改変・再配布（以下，
00012  *  利用と呼ぶ）することを無償で許諾する．
00013  *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
00014  *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
00015  *      スコード中に含まれていること．
00016  *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
00017  *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
00018  *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
00019  *      の無保証規定を掲載すること．
00020  *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
00021  *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
00022  *      と．
00023  *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
00024  *        作権表示，この利用条件および下記の無保証規定を掲載すること．
00025  *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
00026  *        報告すること．
00027  *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
00028  *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
00029  *
00030  *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
00031  *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，その適用可能性も
00032  *  含めて，いかなる保証も行わない．また，本ソフトウェアの利用により直
00033  *  接的または間接的に生じたいかなる損害に関しても，その責任を負わない．
00034  *
00035  *  @(#) $Id: interrupt.hpp,v 1.1.1.1 2004/04/14 09:30:29 takagi-n Exp $
00036  */
00037 
00055 #ifndef TOPPERS_INTERRUPT_HPP_
00056 #define TOPPERS_INTERRUPT_HPP_
00057 
00058 #include <toppers/context.hpp>
00059 
00060 namespace toppers
00061 {
00062 
00063     template <class Body> void interrupthandler_entry();
00064 
00065     template <class Diagnostics, class Stub> class interrupthandler_body;
00066 
00079     template <class Diagnostics = TOPPERS_DEFAULT_DIAGNOSTICS,
00080               class Stub = TOPPERS_DEFAULT_STUB >
00081     class interrupt : Diagnostics
00082     {
00083     public:
00086 
00088         static ER disable(INTNO intno)
00089         {
00090             ER ercd = Stub::stub_dis_int(intno);
00091             return static_handle_error(ercd);
00092         }
00094         static ER enable(INTNO intno)
00095         {
00096             ER ercd = Stub::stub_ena_int(intno);
00097             return static_handle_error(ercd);
00098         }
00099 
00101 
00104 
00106         static ER change_mask(IMS ims)
00107         {
00108             ER ercd = Stub::stub_chg_ims(ims);
00109             return static_handle_error(ercd);
00110         }
00112         static ER get_mask(IMS* p_ims)
00113         {
00114             ER ercd = Stub::stub_get_ims(p_ims);
00115             return static_handle_error(ercd);
00116         }
00117 
00119     };
00120 
00132     template <class Diagnostics = TOPPERS_DEFAULT_DIAGNOSTICS,
00133               class Stub = TOPPERS_DEFAULT_STUB >
00134     class interrupthandler : Diagnostics
00135     {
00136     public:
00138         typedef t_dinh definition;
00139 
00140         //  互換性のための多重定義
00141         static ER define(INHNO inhno, definition* pk_dobj)
00142         {
00143             ER ercd = Stub::stub_def_inh(inhno, pk_dobj);
00144             return static_handle_error(ercd);
00145         }
00147         static ER define(INHNO inhno, const definition* pk_dobj)
00148         {
00149             ER ercd = Stub::stub_def_inh(inhno, pk_dobj);
00150             return static_handle_error(ercd);
00151         }
00153         static ER define(INHNO inhno, ATR inhatr, void (*inthdr)())
00154         {
00155             definition packet;
00156             packet.inhatr = inhatr;
00157             packet.inthdr = FP(inthdr);
00158             return define(inhno, &packet);
00159         }
00161         template <class Body>
00162         static ER define(INHNO inhno, ATR inhatr = 0)
00163         {
00164             return define(inhno, inhatr, &interrupthandler_entry<Body>);
00165         }
00167         static ER undefine(INHNO inhno)
00168         {
00169             return define(inhno, static_cast<definition*>(0));
00170         }
00171     };
00172 
00183     template <class Diagnostics = TOPPERS_DEFAULT_DIAGNOSTICS,
00184               class Stub = TOPPERS_DEFAULT_STUB >
00185     class interrupthandler_body : public non_task_context_body<Diagnostics, Stub>
00186     {
00187     protected:
00188         ~interrupthandler_body() {}
00189 
00190     public:
00191         interrupthandler_body() {}
00192     };
00193 
00204     template <class Body>
00205     inline void interrupthandler_entry()
00206     {
00207         Body body;
00208         body.run();
00209     }
00210 
00211 
00212     template <class Body> void isr_entry(VP_INT);
00213 
00214     template <class Diagnostics, class Stub> class isr_body;
00215 
00227     template <ID Id = 0,
00228               class Diagnostics = TOPPERS_DEFAULT_DIAGNOSTICS,
00229               class Stub = TOPPERS_DEFAULT_STUB >
00230     class isr : Diagnostics
00231     {
00232         typedef object_controller<Id, obj_isr, Stub> controller;
00233         object_id<Id> objid_;
00234 
00235     public:
00237         typedef t_cisr creation;
00239         typedef t_risr reference;
00241         typedef isr_body<Diagnostics, Stub> body;
00242 
00245 
00247         isr() {}
00249         explicit isr(ID id) : objid_(id) {}
00250 
00252         template <ID Id2, class Diagnostics2, class Stub2>
00253         isr(const isr<Id2, Diagnostics2, Stub2>& other)
00254             : objid_(get_unsafe_id(other))
00255         {
00256             TOPPERS_STATIC_ASSERT(Id == 0);
00257         }
00258 
00260 
00263 
00264         //  互換性のための多重定義
00265         ER create(creation* pk_cobj)
00266         {
00267             ER ercd = controller::create(objid_, pk_cobj);
00268             return handle_error(ercd);
00269         }
00271         ER create(const creation* pk_cobj)
00272         {
00273             ER ercd = controller::create(objid_, pk_cobj);
00274             return handle_error(ercd);
00275         }
00277         ER create(ATR isratr, VP_INT exinf, INTNO intno, void (*entry)(VP_INT))
00278         {
00279             creation packet;
00280             packet.isratr = isratr;
00281             packet.exinf  = exinf;
00282             packet.intno  = intno;
00283             packet.isr    = FP(entry);
00284             return create(&packet);
00285         }
00287         template <class Body>
00288         ER create(ATR isratr, VP_INT exinf, INTNO intno)
00289         {
00290             return create(isratr & ~TA_ASM | TA_HLNG, exinf, intno, &isr_entry<Body>);
00291         }
00293         ER destroy()
00294         {
00295             ER ercd = controller::destroy(objid_);
00296             return handle_error(ercd);
00297         }
00298 
00300 
00303 
00305         ER refer(reference* pk_robj) const
00306         {
00307             ER ercd = controller::refer(objid_, pk_robj);
00308             return handle_error(ercd);
00309         }
00310 
00312 
00314         friend ID get_unsafe_id(const isr<Id, Diagnostics, Stub>& obj)
00315         {
00316             return obj.objid_.id();
00317         }
00318     };
00319 
00330     template <class Diagnostics = TOPPERS_DEFAULT_DIAGNOSTICS,
00331               class Stub = TOPPERS_DEFAULT_STUB >
00332     class isr_body : public non_task_context_body<Diagnostics, Stub>
00333     {
00334         VP_INT exinf_;
00335 
00336     protected:
00337         ~isr_body() {}
00338 
00339     public:
00341         explicit isr_body(VP_INT exinf) : exinf_(exinf) {}
00342 
00344         VP_INT get_extended_info() const { return exinf_; }
00345     };
00346 
00357     template <class Body>
00358     inline void isr_entry(VP_INT exinf)
00359     {
00360         Body body(exinf);
00361         body.run();
00362     }
00363 
00364 }
00365 
00366 #endif  // ! TOPPERS_INTERRUPT_HPP_