source: rtems/testsuites/libtests/i2c01/init.c @ 5bb5e01

Last change on this file since 5bb5e01 was 5bb5e01, checked in by Christian Mauderer <christian.mauderer@…>, on May 26, 2021 at 2:33:40 PM

i2c: Add non blocking read / write

This adds the possibility to open an I2C bus with O_NONBLOCK (or set it
later via fcntl) to get non-blocking transmissions. This means that if
the bus is busy, a read, write or transfer ioctl will return with a
EAGAIN errno.

  • Property mode set to 100644
File size: 17.3 KB
Line 
1/*
2 * Copyright (c) 2014 embedded brains GmbH.  All rights reserved.
3 *
4 *  embedded brains GmbH
5 *  Dornierstr. 4
6 *  82178 Puchheim
7 *  Germany
8 *  <rtems@embedded-brains.de>
9 *
10 * The license and distribution terms for this file may be
11 * found in the file LICENSE in this distribution or at
12 * http://www.rtems.org/license/LICENSE.
13 */
14
15#ifdef HAVE_CONFIG_H
16#include "config.h"
17#endif
18
19#include <dev/i2c/i2c.h>
20#include <dev/i2c/eeprom.h>
21#include <dev/i2c/gpio-nxp-pca9535.h>
22#include <dev/i2c/switch-nxp-pca9548a.h>
23
24#include <sys/ioctl.h>
25#include <sys/stat.h>
26#include <errno.h>
27#include <fcntl.h>
28#include <stdlib.h>
29#include <string.h>
30#include <unistd.h>
31
32#include <rtems/libcsupport.h>
33
34#include "tmacros.h"
35
36const char rtems_test_name[] = "I2C 1";
37
38#define SPARE_ADDRESS_BITS 3
39
40#define DEVICE_SIMPLE_READ_WRITE (0UL << SPARE_ADDRESS_BITS)
41
42#define DEVICE_EEPROM (1UL << SPARE_ADDRESS_BITS)
43
44#define DEVICE_GPIO_NXP_PCA9535 (2UL << SPARE_ADDRESS_BITS)
45
46#define DEVICE_SWITCH_NXP_PCA9548A (3UL << SPARE_ADDRESS_BITS)
47
48#define EEPROM_SIZE 512
49
50typedef struct test_device test_device;
51
52struct test_device {
53  int (*transfer)(
54    i2c_bus *bus,
55    i2c_msg *msgs,
56    uint32_t msg_count,
57    test_device *dev
58  );
59};
60
61typedef struct {
62  test_device base;
63  char buf[3];
64} test_device_simple_read_write;
65
66typedef struct {
67  test_device base;
68  unsigned current_reg;
69  uint8_t regs[8];
70} test_device_gpio_nxp_pca9535;
71
72typedef struct {
73  test_device base;
74  bool eio;
75  unsigned current_address;
76  uint8_t data[EEPROM_SIZE];
77} test_device_eeprom;
78
79typedef struct {
80  test_device base;
81  uint8_t control;
82} test_device_switch_nxp_pca9548a;
83
84typedef struct {
85  i2c_bus base;
86  unsigned long clock;
87  test_device *devices[4];
88  test_device_simple_read_write simple_read_write;
89  test_device_gpio_nxp_pca9535 gpio_nxp_pca9535;
90  test_device_eeprom eeprom;
91  test_device_switch_nxp_pca9548a switch_nxp_pca9548a;
92} test_bus;
93
94static const char bus_path[] = "/dev/i2c-0";
95
96static const char gpio_nxp_pca9535_path[] = "/dev/i2c-0.gpio-nxp-pc9535-0";
97
98static const char eeprom_path[] = "/dev/i2c-0.eeprom-0";
99
100static const char switch_nxp_pca9548a_path[] =
101  "/dev/i2c-0.switch-nxp-pca9548a-0";
102
103static void cyclic_inc(unsigned *val, unsigned cycle)
104{
105  unsigned v = *val;
106  unsigned m = cycle - 1U;
107
108  *val = (v & ~m) + ((v + 1U) & m);
109}
110
111static int test_simple_read_write_transfer(
112  i2c_bus *bus,
113  i2c_msg *msgs,
114  uint32_t msg_count,
115  test_device *base
116)
117{
118  test_device_simple_read_write *dev = (test_device_simple_read_write *) base;
119
120  if (msg_count == 1 && msgs[0].len == sizeof(dev->buf)) {
121    if ((msgs[0].flags & I2C_M_RD) != 0) {
122      memcpy(msgs[0].buf, &dev->buf[0], sizeof(dev->buf));
123    } else {
124      memcpy(&dev->buf[0], msgs[0].buf, sizeof(dev->buf));
125    }
126
127    return 0;
128  } else {
129    return -EIO;
130  }
131}
132
133static int test_gpio_nxp_pca9535_transfer(
134  i2c_bus *bus,
135  i2c_msg *msgs,
136  uint32_t msg_count,
137  test_device *base
138)
139{
140  test_device_gpio_nxp_pca9535 *dev = (test_device_gpio_nxp_pca9535 *) base;
141  i2c_msg *first = &msgs[0];
142  i2c_msg *second = &msgs[1];
143  int i;
144
145  /* Get command byte */
146  if (
147    msg_count < 1
148      || (first->flags & I2C_M_RD) != 0
149      || first->len < 1
150  ) {
151    return -EIO;
152  }
153
154  dev->current_reg = first->buf[0];
155
156  if (first->len > 1) {
157    /* Write */
158
159    if (msg_count != 1) {
160      return -EIO;
161    }
162
163    for (i = 1; i < first->len; ++i) {
164      dev->regs[dev->current_reg] = first->buf[i];
165
166      /* Output is input */
167      if (dev->current_reg == 2) {
168        dev->regs[0] = first->buf[i];
169      } else if (dev->current_reg == 3) {
170        dev->regs[1] = first->buf[i];
171      }
172
173      cyclic_inc(&dev->current_reg, 2);
174    }
175  } else {
176    /* Read */
177
178    if (msg_count != 2) {
179      return -EIO;
180    }
181
182    for (i = 0; i < second->len; ++i) {
183      second->buf[i] = dev->regs[dev->current_reg];
184      cyclic_inc(&dev->current_reg, 2);
185    }
186  }
187
188  return 0;
189}
190
191static int test_eeprom_transfer(
192  i2c_bus *bus,
193  i2c_msg *msgs,
194  uint32_t msg_count,
195  test_device *base
196)
197{
198  test_device_eeprom *dev = (test_device_eeprom *) base;
199  i2c_msg *msg = &msgs[0];
200  uint32_t i;
201
202  if (dev->eio) {
203    return -EIO;
204  }
205
206  if (msg_count > 0 && (msg->flags & I2C_M_RD) == 0) {
207    if (msg->len < 1) {
208      return -EIO;
209    }
210
211    dev->current_address = msg->buf[0] | ((msg->addr & 0x1) << 8);
212    --msg->len;
213    ++msg->buf;
214  }
215
216  for (i = 0; i < msg_count; ++i) {
217    int j;
218
219    msg = &msgs[i];
220
221    if ((msg->flags & I2C_M_RD) != 0) {
222      for (j = 0; j < msg->len; ++j) {
223        msg->buf[j] = dev->data[dev->current_address];
224        cyclic_inc(&dev->current_address, sizeof(dev->data));
225      }
226    } else {
227      for (j = 0; j < msg->len; ++j) {
228        dev->data[dev->current_address] = msg->buf[j];
229        cyclic_inc(&dev->current_address, 8);
230      }
231    }
232  }
233
234  return 0;
235}
236
237static int test_switch_nxp_pca9548a_transfer(
238  i2c_bus *bus,
239  i2c_msg *msgs,
240  uint32_t msg_count,
241  test_device *base
242)
243{
244  test_device_switch_nxp_pca9548a *dev = (test_device_switch_nxp_pca9548a *) base;
245  uint32_t i;
246
247  for (i = 0; i < msg_count; ++i) {
248    i2c_msg *msg = &msgs[i];
249    int j;
250
251    if ((msg->flags & I2C_M_RD) != 0) {
252      for (j = 0; j < msg->len; ++j) {
253        msg->buf[j] = dev->control;
254      }
255    } else {
256      for (j = 0; j < msg->len; ++j) {
257        dev->control = msg->buf[j];
258      }
259    }
260  }
261
262  return 0;
263}
264
265static int test_transfer(i2c_bus *base, i2c_msg *msgs, uint32_t msg_count)
266{
267  test_bus *bus = (test_bus *) base;
268  uint16_t addr;
269  test_device *dev;
270
271  addr = msgs[0].addr >> SPARE_ADDRESS_BITS;
272  if (addr >= RTEMS_ARRAY_SIZE(bus->devices)) {
273    return -EIO;
274  }
275
276  dev = bus->devices[addr];
277
278  return (*dev->transfer)(&bus->base, msgs, msg_count, dev);
279}
280
281static int test_set_clock(i2c_bus *base, unsigned long clock)
282{
283  test_bus *bus = (test_bus *) base;
284
285  bus->clock = clock;
286
287  return 0;
288}
289
290static void test_destroy(i2c_bus *base)
291{
292  i2c_bus_destroy_and_free(base);
293}
294
295static void test_simple_read_write(test_bus *bus, int fd)
296{
297  static const char zero[] = { 0, 0, 0 };
298  static const char abc[] = { 'a', 'b', 'c' };
299
300  int rv;
301  char buf[3];
302  ssize_t n;
303
304  rv = ioctl(fd, I2C_SLAVE, DEVICE_SIMPLE_READ_WRITE);
305  rtems_test_assert(rv == 0);
306
307  errno = 0;
308  rv = ioctl(fd, 0xb00b);
309  rtems_test_assert(rv == -1);
310  rtems_test_assert(errno == ENOTTY);
311
312  errno = 0;
313  n = write(fd, &buf[0], 1000);
314  rtems_test_assert(n == -1);
315  rtems_test_assert(errno == EIO);
316
317  errno = 0;
318  n = read(fd, &buf[0], 1000);
319  rtems_test_assert(n == -1);
320  rtems_test_assert(errno == EIO);
321
322  rtems_test_assert(
323    memcmp(&bus->simple_read_write.buf[0], &zero[0], sizeof(buf)) == 0
324  );
325
326  n = write(fd, &abc[0], sizeof(buf));
327  rtems_test_assert(n == (ssize_t) sizeof(buf));
328
329  rtems_test_assert(
330    memcmp(&bus->simple_read_write.buf[0], &abc[0], sizeof(buf)) == 0
331  );
332
333  n = read(fd, &buf[0], sizeof(buf));
334  rtems_test_assert(n == (ssize_t) sizeof(buf));
335
336  rtems_test_assert(memcmp(&buf[0], &abc[0], sizeof(buf)) == 0);
337}
338
339typedef struct {
340  rtems_id caller;
341  int fd;
342} bus_obtainer_ctx;
343
344static void bus_obtainer_task(rtems_task_argument arg)
345{
346  rtems_event_set e = 0;
347  bus_obtainer_ctx *c = (bus_obtainer_ctx *) arg;
348  int rv;
349  rtems_status_code sc;
350
351  rv = ioctl(c->fd, I2C_BUS_OBTAIN);
352  rtems_test_assert(rv == 0);
353
354  sc = rtems_event_send(c->caller, RTEMS_EVENT_1);
355  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
356  sc = rtems_event_receive(
357    RTEMS_EVENT_1,
358    RTEMS_EVENT_ANY | RTEMS_WAIT,
359    100,
360    &e
361  );
362  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
363
364  rv = ioctl(c->fd, I2C_BUS_RELEASE);
365  rtems_test_assert(rv == 0);
366
367  sc = rtems_event_send(c->caller, RTEMS_EVENT_1);
368  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
369}
370
371static void test_nonblock_read_write(test_bus *bus, int fd)
372{
373  int flags;
374  int rv;
375  char buf[3];
376  ssize_t n;
377  i2c_msg msgs[] = {{
378    .addr = 1,
379    .flags = I2C_M_STOP,
380    .len = sizeof(buf),
381    .buf = (uint8_t *) buf,
382  }};
383  struct i2c_rdwr_ioctl_data payload = {
384    .msgs = msgs,
385    .nmsgs = sizeof(msgs)/sizeof(msgs[0]),
386  };
387  rtems_id id;
388  rtems_event_set e = 0;
389  bus_obtainer_ctx ctx = {
390    .caller = rtems_task_self(),
391    .fd = fd,
392  };
393  rtems_status_code sc;
394
395  flags = fcntl(fd, F_GETFL, 0);
396  rtems_test_assert(flags > 0);
397
398  rv = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
399  rtems_test_assert(rv != -1);
400
401  sc = rtems_task_create(
402    rtems_build_name('O', 'B', 'T', 'A'),
403    2,
404    RTEMS_MINIMUM_STACK_SIZE,
405    RTEMS_DEFAULT_MODES,
406    RTEMS_DEFAULT_ATTRIBUTES,
407    &id
408  );
409  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
410
411  sc = rtems_task_start(
412    id,
413    bus_obtainer_task,
414    (rtems_task_argument) &ctx
415  );
416  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
417
418  sc = rtems_event_receive(
419    RTEMS_EVENT_1,
420    RTEMS_EVENT_ANY | RTEMS_WAIT,
421    100,
422    &e
423  );
424  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
425
426  errno = 0;
427  n = read(fd, &buf[0], sizeof(buf));
428  rtems_test_assert(n == -1);
429  rtems_test_assert(errno == EAGAIN);
430
431  errno = 0;
432  n = write(fd, &buf[0], sizeof(buf));
433  rtems_test_assert(n == -1);
434  rtems_test_assert(errno == EAGAIN);
435
436  errno = 0;
437  rv = ioctl(fd, I2C_RDWR, &payload);
438  rtems_test_assert(rv == -1);
439  rtems_test_assert(errno == EAGAIN);
440
441  sc = rtems_event_send(id, RTEMS_EVENT_1);
442  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
443  sc = rtems_event_receive(
444    RTEMS_EVENT_1,
445    RTEMS_EVENT_ANY | RTEMS_WAIT,
446    100,
447    &e
448  );
449  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
450  sc = rtems_task_delete(id);
451  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
452
453  rv = fcntl(fd, F_SETFL, flags);
454  rtems_test_assert(rv != -1);
455}
456
457static void test_gpio_nxp_pca9535(void)
458{
459  int rv;
460  int fd;
461  uint16_t val;
462
463  rv = i2c_dev_register_gpio_nxp_pca9535(
464    &bus_path[0],
465    &gpio_nxp_pca9535_path[0],
466    DEVICE_GPIO_NXP_PCA9535
467  );
468  rtems_test_assert(rv == 0);
469
470  fd = open(&gpio_nxp_pca9535_path[0], O_RDWR);
471  rtems_test_assert(fd >= 0);
472
473  rv = gpio_nxp_pca9535_get_input(fd, &val);
474  rtems_test_assert(rv == 0);
475  rtems_test_assert(val == 0);
476
477  rv = gpio_nxp_pca9535_get_output(fd, &val);
478  rtems_test_assert(rv == 0);
479  rtems_test_assert(val == 0);
480
481  rv = gpio_nxp_pca9535_set_output(fd, 0xa5ef);
482  rtems_test_assert(rv == 0);
483
484  rv = gpio_nxp_pca9535_get_input(fd, &val);
485  rtems_test_assert(rv == 0);
486  rtems_test_assert(val == 0xa5ef);
487
488  rv = gpio_nxp_pca9535_get_output(fd, &val);
489  rtems_test_assert(rv == 0);
490  rtems_test_assert(val == 0xa5ef);
491
492  rv = gpio_nxp_pca9535_clear_and_set_output(fd, 0x0ff0, 0x0170);
493  rtems_test_assert(rv == 0);
494
495  rv = gpio_nxp_pca9535_get_polarity_inversion(fd, &val);
496  rtems_test_assert(rv == 0);
497  rtems_test_assert(val == 0);
498
499  rv = gpio_nxp_pca9535_set_polarity_inversion(fd, 0x5afe);
500  rtems_test_assert(rv == 0);
501
502  rv = gpio_nxp_pca9535_get_config(fd, &val);
503  rtems_test_assert(rv == 0);
504  rtems_test_assert(val == 0);
505
506  rv = gpio_nxp_pca9535_set_config(fd, 0x2bcd);
507  rtems_test_assert(rv == 0);
508
509  rv = gpio_nxp_pca9535_get_input(fd, &val);
510  rtems_test_assert(rv == 0);
511  rtems_test_assert(val == 0xa17f);
512
513  rv = gpio_nxp_pca9535_get_output(fd, &val);
514  rtems_test_assert(rv == 0);
515  rtems_test_assert(val == 0xa17f);
516
517  rv = gpio_nxp_pca9535_get_polarity_inversion(fd, &val);
518  rtems_test_assert(rv == 0);
519  rtems_test_assert(val == 0x5afe);
520
521  rv = gpio_nxp_pca9535_get_config(fd, &val);
522  rtems_test_assert(rv == 0);
523  rtems_test_assert(val == 0x2bcd);
524
525  rv = close(fd);
526  rtems_test_assert(rv == 0);
527
528  rv = unlink(&gpio_nxp_pca9535_path[0]);
529  rtems_test_assert(rv == 0);
530}
531
532static void test_eeprom(test_bus *bus)
533{
534  int rv;
535  int fd_in;
536  int fd_out;
537  struct stat st;
538  uint8_t in[EEPROM_SIZE];
539  uint8_t out[EEPROM_SIZE];
540  ssize_t n;
541  off_t off;
542  size_t i;
543
544  rv = i2c_dev_register_eeprom(
545    &bus_path[0],
546    &eeprom_path[0],
547    DEVICE_EEPROM,
548    1,
549    8,
550    sizeof(out),
551    0
552  );
553  rtems_test_assert(rv == 0);
554
555  fd_in = open(&eeprom_path[0], O_RDWR);
556  rtems_test_assert(fd_in >= 0);
557
558  fd_out = open(&eeprom_path[0], O_RDWR);
559  rtems_test_assert(fd_out >= 0);
560
561  rv = fstat(fd_in, &st);
562  rtems_test_assert(rv == 0);
563  rtems_test_assert(st.st_blksize == 8);
564  rtems_test_assert(st.st_size == sizeof(out));
565
566  memset(&out[0], 0, sizeof(out));
567
568  bus->eeprom.eio = true;
569
570  errno = 0;
571  n = read(fd_in, &in[0], 1);
572  rtems_test_assert(n == -1);
573  rtems_test_assert(errno == EIO);
574
575  errno = 0;
576  n = write(fd_out, &out[0], 1);
577  rtems_test_assert(n == -1);
578  rtems_test_assert(errno == EIO);
579
580  bus->eeprom.eio = false;
581
582  n = read(fd_in, &in[0], sizeof(in) + 1);
583  rtems_test_assert(n == (ssize_t) sizeof(in));
584
585  rtems_test_assert(memcmp(&in[0], &out[0], sizeof(in)) == 0);
586
587  off = lseek(fd_in, 0, SEEK_CUR);
588  rtems_test_assert(off == sizeof(out));
589
590  for (i = 0; i < sizeof(out); ++i) {
591    off = lseek(fd_out, 0, SEEK_CUR);
592    rtems_test_assert(off == i);
593
594    out[i] = (uint8_t) i;
595
596    n = write(fd_out, &out[i], sizeof(out[i]));
597    rtems_test_assert(n == (ssize_t) sizeof(out[i]));
598
599    off = lseek(fd_in, 0, SEEK_SET);
600    rtems_test_assert(off == 0);
601
602    n = read(fd_in, &in[0], sizeof(in));
603    rtems_test_assert(n == (ssize_t) sizeof(in));
604
605    rtems_test_assert(memcmp(&in[0], &out[0], sizeof(in)) == 0);
606  }
607
608  rv = close(fd_in);
609  rtems_test_assert(rv == 0);
610
611  rv = close(fd_out);
612  rtems_test_assert(rv == 0);
613
614  rv = unlink(&eeprom_path[0]);
615  rtems_test_assert(rv == 0);
616}
617
618static void test_switch_nxp_pca9548a(void)
619{
620  int rv;
621  int fd;
622  uint8_t val;
623
624  rv = i2c_dev_register_switch_nxp_pca9548a(
625    &bus_path[0],
626    &switch_nxp_pca9548a_path[0],
627    DEVICE_SWITCH_NXP_PCA9548A
628  );
629  rtems_test_assert(rv == 0);
630
631  fd = open(&switch_nxp_pca9548a_path[0], O_RDWR);
632  rtems_test_assert(fd >= 0);
633
634  rv = switch_nxp_pca9548a_get_control(fd, &val);
635  rtems_test_assert(rv == 0);
636  rtems_test_assert(val == 0);
637
638  rv = switch_nxp_pca9548a_set_control(fd, 0xa5);
639  rtems_test_assert(rv == 0);
640
641  rv = switch_nxp_pca9548a_get_control(fd, &val);
642  rtems_test_assert(rv == 0);
643  rtems_test_assert(val == 0xa5);
644
645  rv = close(fd);
646  rtems_test_assert(rv == 0);
647
648  rv = unlink(&switch_nxp_pca9548a_path[0]);
649  rtems_test_assert(rv == 0);
650}
651
652static void test(void)
653{
654  rtems_resource_snapshot snapshot;
655  test_bus *bus;
656  int rv;
657  int fd;
658
659  rtems_resource_snapshot_take(&snapshot);
660
661  bus = (test_bus *) i2c_bus_alloc_and_init(sizeof(*bus));
662  rtems_test_assert(bus != NULL);
663
664  bus->base.transfer = test_transfer;
665  bus->base.set_clock = test_set_clock;
666  bus->base.destroy = test_destroy;
667  bus->base.functionality = I2C_FUNC_I2C | I2C_FUNC_PROTOCOL_MANGLING
668    | I2C_FUNC_NOSTART;
669
670  bus->simple_read_write.base.transfer = test_simple_read_write_transfer;
671  bus->devices[0] = &bus->simple_read_write.base;
672
673  bus->eeprom.base.transfer = test_eeprom_transfer;
674  bus->devices[1] = &bus->eeprom.base;
675
676  bus->gpio_nxp_pca9535.base.transfer = test_gpio_nxp_pca9535_transfer;
677  bus->devices[2] = &bus->gpio_nxp_pca9535.base;
678
679  bus->switch_nxp_pca9548a.base.transfer = test_switch_nxp_pca9548a_transfer;
680  bus->devices[3] = &bus->switch_nxp_pca9548a.base;
681
682  rv = i2c_bus_register(&bus->base, &bus_path[0]);
683  rtems_test_assert(rv == 0);
684
685  fd = open(&bus_path[0], O_RDWR);
686  rtems_test_assert(fd >= 0);
687
688  rtems_test_assert(bus->clock == 0);
689  rv = ioctl(fd, I2C_BUS_SET_CLOCK, 0xdeadbeefUL);
690  rtems_test_assert(rv == 0);
691  rtems_test_assert(bus->clock == 0xdeadbeef);
692
693  rv = ioctl(fd, I2C_BUS_OBTAIN);
694  rtems_test_assert(rv == 0);
695
696  rv = ioctl(fd, I2C_BUS_RELEASE);
697  rtems_test_assert(rv == 0);
698
699  rtems_test_assert(!bus->base.ten_bit_address);
700
701  rv = ioctl(fd, I2C_TENBIT, 1UL);
702  rtems_test_assert(rv == 0);
703  rtems_test_assert(bus->base.ten_bit_address);
704
705  rv = ioctl(fd, I2C_TENBIT, 0UL);
706  rtems_test_assert(rv == 0);
707  rtems_test_assert(!bus->base.ten_bit_address);
708
709  rtems_test_assert(!bus->base.use_pec);
710
711  rv = ioctl(fd, I2C_PEC, 1UL);
712  rtems_test_assert(rv == 0);
713  rtems_test_assert(bus->base.use_pec);
714
715  rv = ioctl(fd, I2C_PEC, 0UL);
716  rtems_test_assert(rv == 0);
717  rtems_test_assert(!bus->base.use_pec);
718
719  rv = ioctl(fd, I2C_SLAVE, 123UL);
720  rtems_test_assert(rv == 0);
721  rtems_test_assert(bus->base.default_address == 123);
722
723  rv = ioctl(fd, I2C_SLAVE_FORCE, 456UL);
724  rtems_test_assert(rv == 0);
725  rtems_test_assert(bus->base.default_address == 456);
726
727  rtems_test_assert(bus->base.retries == 0);
728
729  rv = ioctl(fd, I2C_RETRIES, 1UL);
730  rtems_test_assert(rv == 0);
731  rtems_test_assert(bus->base.retries == 1);
732
733  rv = ioctl(fd, I2C_RETRIES, 0UL);
734  rtems_test_assert(rv == 0);
735  rtems_test_assert(bus->base.retries == 0);
736
737  rtems_test_assert(bus->base.timeout == 0);
738
739  rv = ioctl(fd, I2C_TIMEOUT, 1UL);
740  rtems_test_assert(rv == 0);
741  rtems_test_assert(bus->base.timeout == 5);
742
743  rv = ioctl(fd, I2C_TIMEOUT, 0UL);
744  rtems_test_assert(rv == 0);
745  rtems_test_assert(bus->base.timeout == 0);
746
747  test_simple_read_write(bus, fd);
748  test_nonblock_read_write(bus, fd);
749  test_eeprom(bus);
750  test_gpio_nxp_pca9535();
751  test_switch_nxp_pca9548a();
752
753  rv = close(fd);
754  rtems_test_assert(rv == 0);
755
756  rv = unlink(&bus_path[0]);
757  rtems_test_assert(rv == 0);
758
759  rtems_test_assert(rtems_resource_snapshot_check(&snapshot));
760}
761
762static void Init(rtems_task_argument arg)
763{
764  TEST_BEGIN();
765
766  test();
767
768  TEST_END();
769  rtems_test_exit(0);
770}
771
772#define CONFIGURE_MICROSECONDS_PER_TICK 2000
773
774#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
775#define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
776
777#define CONFIGURE_MAXIMUM_FILE_DESCRIPTORS 7
778
779#define CONFIGURE_MAXIMUM_TASKS 2
780
781#define CONFIGURE_MAXIMUM_SEMAPHORES 1
782
783#define CONFIGURE_INIT_TASK_STACK_SIZE (RTEMS_MINIMUM_STACK_SIZE + 2 * EEPROM_SIZE)
784
785#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
786
787#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
788
789#define CONFIGURE_INIT
790
791#include <rtems/confdefs.h>
Note: See TracBrowser for help on using the repository browser.