libtests/irqs01/init.c

0001 /* SPDX-License-Identifier: BSD-2-Clause */
0002
0003 /*
0004  * Copyright (C) 2020 embedded brains GmbH & Co. KG
0005  *
0006  * Redistribution and use in source and binary forms, with or without
0007  * modification, are permitted provided that the following conditions
0008  * are met:
0009  * 1. Redistributions of source code must retain the above copyright
0010  *    notice, this list of conditions and the following disclaimer.
0011  * 2. Redistributions in binary form must reproduce the above copyright
0012  *    notice, this list of conditions and the following disclaimer in the
0013  *    documentation and/or other materials provided with the distribution.
0014  *
0015  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
0016  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
0017  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
0018  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
0019  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
0020  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
0021  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
0022  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
0023  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
0024  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
0025  * POSSIBILITY OF SUCH DAMAGE.
0026  */
0027
0028 #ifdef HAVE_CONFIG_H
0029 #include "config.h"
0030 #endif
0031
0032 #include <rtems/test.h>
0033 #include <rtems/test-info.h>
0034
0035 #include <rtems.h>
0036 #include <rtems/irq-extension.h>
0037
0038 typedef struct {
0039   rtems_interrupt_server_control base;
0040   int magic;
0041 } server_control;
0042
0043 static void destroy(rtems_interrupt_server_control *base)
0044 {
0045   server_control *control;
0046
0047   control = (server_control *) base;
0048   T_step_eq_int(2, control->magic, 0x54192a88);
0049 }
0050
0051 static const rtems_interrupt_server_config valid_config = {
0052   .name = rtems_build_name('N', 'A', 'M', 'E'),
0053   .priority = 123,
0054   .storage_size = RTEMS_MINIMUM_STACK_SIZE,
0055   .modes = RTEMS_DEFAULT_MODES,
0056   .attributes = RTEMS_DEFAULT_ATTRIBUTES,
0057   .destroy = destroy
0058 };
0059
0060 T_TEST_CASE(InterruptServerCreateDestroy)
0061 {
0062   server_control control;
0063   rtems_status_code sc;
0064   uint32_t server_index;
0065   rtems_task_priority prio;
0066
0067   T_plan(7);
0068
0069   memset(&control, 0xff, sizeof(control));
0070   control.magic = 0x54192a88;
0071   server_index = 0x2833763f;
0072
0073   sc = rtems_interrupt_server_create(
0074     &control.base,
0075     &valid_config,
0076     &server_index
0077   );
0078   T_step_rsc_success(0, sc);
0079   T_step_ne_u32(1, server_index, 0x2833763f);
0080
0081   sc = rtems_interrupt_server_delete(server_index);
0082   T_step_rsc_success(3, sc);
0083
0084   /* Make sure the interrupt server terminated */
0085   prio = 0;
0086   sc = rtems_task_set_priority(RTEMS_SELF, 124, &prio);
0087   T_step_rsc_success(4, sc);
0088   sc = rtems_task_set_priority(RTEMS_SELF, prio, &prio);
0089   T_step_rsc_success(5, sc);
0090   T_step_eq_u32(6, prio, 124);
0091 }
0092
0093 static const rtems_interrupt_server_config invalid_config = {
0094   .name = rtems_build_name('N', 'A', 'M', 'E'),
0095   .priority = 0,
0096   .storage_size = RTEMS_MINIMUM_STACK_SIZE,
0097   .modes = RTEMS_DEFAULT_MODES,
0098   .attributes = RTEMS_DEFAULT_ATTRIBUTES,
0099   .destroy = destroy
0100 };
0101
0102 T_TEST_CASE(InterruptServerCreateError)
0103 {
0104   rtems_interrupt_server_control control;
0105   rtems_interrupt_server_control control_2;
0106   rtems_status_code sc;
0107   uint32_t server_index;
0108
0109   memset(&control, 0xff, sizeof(control));
0110   memset(&control_2, 0xff, sizeof(control_2));
0111   server_index = 0x235e8766;
0112
0113   sc = rtems_interrupt_server_create(&control, &invalid_config, &server_index);
0114   T_rsc(sc, RTEMS_INVALID_PRIORITY);
0115   T_eq_mem(&control, &control_2, sizeof(control));
0116   T_eq_u32(server_index, 0x235e8766);
0117 }
0118
0119 static const rtems_interrupt_server_config request_config = {
0120   .name = rtems_build_name('N', 'A', 'M', 'E'),
0121   .priority = 123,
0122   .storage_size = RTEMS_MINIMUM_STACK_SIZE,
0123   .modes = RTEMS_DEFAULT_MODES,
0124   .attributes = RTEMS_DEFAULT_ATTRIBUTES
0125 };
0126
0127 static void not_called(void *arg)
0128 {
0129   (void) arg;
0130   T_unreachable();
0131 }
0132
0133 static void request(void *arg)
0134 {
0135   rtems_id *id;
0136   rtems_status_code sc;
0137
0138   id = arg;
0139   T_step(4);
0140   sc = rtems_event_transient_send(*id);
0141   T_step_rsc_success(6, sc);
0142 }
0143
0144 T_TEST_CASE(InterruptServerRequest)
0145 {
0146   rtems_interrupt_server_control control;
0147   rtems_interrupt_server_request req;
0148   rtems_status_code sc;
0149   uint32_t server_index;
0150   rtems_id id;
0151   rtems_task_priority prio;
0152
0153   T_plan(11);
0154
0155   memset(&control, 0xff, sizeof(control));
0156   memset(&req, 0xff, sizeof(req));
0157   server_index = 0x99d225bd;
0158
0159   sc = rtems_interrupt_server_create(
0160     &control,
0161     &request_config,
0162     &server_index
0163   );
0164   T_step_rsc_success(0, sc);
0165   T_step_ne_u32(1, server_index, 0x99d225bd);
0166
0167   sc = rtems_interrupt_server_request_initialize(
0168     server_index,
0169     &req,
0170     not_called,
0171     NULL
0172   );
0173   T_step_rsc_success(2, sc);
0174
0175   rtems_interrupt_server_request_submit(&req);
0176   rtems_interrupt_server_request_destroy(&req);
0177
0178   id = rtems_task_self();
0179   sc = rtems_interrupt_server_request_initialize(
0180     server_index,
0181     &req,
0182     request,
0183     &id
0184   );
0185   T_step_rsc_success(3, sc);
0186
0187   rtems_interrupt_server_request_submit(&req);
0188   sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
0189   T_step_rsc_success(5, sc);
0190
0191   rtems_interrupt_server_request_destroy(&req);
0192
0193   sc = rtems_interrupt_server_delete(server_index);
0194   T_step_rsc_success(7, sc);
0195
0196   /* Make sure the interrupt server terminated */
0197   prio = 0;
0198   sc = rtems_task_set_priority(RTEMS_SELF, 124, &prio);
0199   T_step_rsc_success(8, sc);
0200   sc = rtems_task_set_priority(RTEMS_SELF, prio, &prio);
0201   T_step_rsc_success(9, sc);
0202   T_step_eq_u32(10, prio, 124);
0203 }
0204
0205 T_TEST_CASE(InterruptServerInitializeDestroy)
0206 {
0207   rtems_status_code sc;
0208   uint32_t server_count;
0209   rtems_task_priority prio;
0210
0211   sc = rtems_interrupt_server_delete(0);
0212   T_rsc(sc, RTEMS_INVALID_ID);
0213
0214   server_count = 456;
0215   sc = rtems_interrupt_server_initialize(
0216     123,
0217     RTEMS_MINIMUM_STACK_SIZE,
0218     RTEMS_DEFAULT_MODES,
0219     RTEMS_DEFAULT_ATTRIBUTES,
0220     &server_count
0221   );
0222   T_rsc_success(sc);
0223   T_eq_u32(server_count, 1);
0224
0225   server_count = 456;
0226   sc = rtems_interrupt_server_initialize(
0227     123,
0228     RTEMS_MINIMUM_STACK_SIZE,
0229     RTEMS_DEFAULT_MODES,
0230     RTEMS_DEFAULT_ATTRIBUTES,
0231     &server_count
0232   );
0233   T_rsc(sc, RTEMS_INCORRECT_STATE);
0234   T_eq_u32(server_count, 0);
0235
0236   sc = rtems_interrupt_server_delete(0);
0237   T_rsc_success(sc);
0238
0239   /* Make sure the interrupt server terminated */
0240   prio = 0;
0241   sc = rtems_task_set_priority(RTEMS_SELF, 124, &prio);
0242   T_rsc_success(sc);
0243   sc = rtems_task_set_priority(RTEMS_SELF, prio, &prio);
0244   T_rsc_success(sc);
0245   T_eq_u32(prio, 124);
0246
0247   server_count = 456;
0248   sc = rtems_interrupt_server_initialize(
0249     0,
0250     RTEMS_MINIMUM_STACK_SIZE,
0251     RTEMS_DEFAULT_MODES,
0252     RTEMS_DEFAULT_ATTRIBUTES,
0253     &server_count
0254   );
0255   T_rsc(sc, RTEMS_INVALID_PRIORITY);
0256   T_eq_u32(server_count, 0);
0257
0258   server_count = 456;
0259   sc = rtems_interrupt_server_initialize(
0260     123,
0261     RTEMS_MINIMUM_STACK_SIZE,
0262     RTEMS_DEFAULT_MODES,
0263     RTEMS_DEFAULT_ATTRIBUTES,
0264     &server_count
0265   );
0266   T_rsc_success(sc);
0267   T_eq_u32(server_count, 1);
0268
0269   sc = rtems_interrupt_server_delete(0);
0270   T_rsc_success(sc);
0271
0272   /* Make sure the interrupt server terminated */
0273   prio = 0;
0274   sc = rtems_task_set_priority(RTEMS_SELF, 124, &prio);
0275   T_rsc_success(sc);
0276   sc = rtems_task_set_priority(RTEMS_SELF, prio, &prio);
0277   T_rsc_success(sc);
0278   T_eq_u32(prio, 124);
0279 }
0280
0281 const char rtems_test_name[] = "IRQS 1";
0282
0283 static void Init(rtems_task_argument argument)
0284 {
0285   rtems_test_run(argument, TEST_STATE);
0286 }
0287
0288 #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
0289 #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
0290
0291 #define CONFIGURE_MAXIMUM_TASKS 2
0292
0293 #define CONFIGURE_RTEMS_INIT_TASKS_TABLE
0294
0295 #define CONFIGURE_INIT_TASK_INITIAL_MODES RTEMS_DEFAULT_MODES
0296
0297 #define CONFIGURE_INIT
0298
0299 #include <rtems/confdefs.h>