The channel information is simple, since it contains only the signal range information:

struct comedi_lrange_struct{
  int           length;
  comedi_krange range[GCC_ZERO_LENGTH_ARRAY];
};

The subdevice is the smallest Comedi entity that can be used for “stand-alone” DAQ, so it is no surprise that it is quite big:

struct comedi_subdevice_struct{
  int  type;
  int  n_chan;
  int  subdev_flags;
  int  len_chanlist;		/* maximum length of channel/gain list */

  void *private;

  comedi_async *async;

  void         *lock;
  void         *busy;
  unsigned int runflags;

  int          io_bits;

  lsampl_t maxdata;       /* if maxdata==0, use list */
  lsampl_t *maxdata_list; /* list is channel specific */

  unsigned int flags;
  unsigned int *flaglist;

  comedi_lrange *range_table;
  comedi_lrange **range_table_list;

  unsigned int *chanlist;		/* driver-owned chanlist (not used) */

  int (*insn_read)(comedi_device *,comedi_subdevice *,comedi_insn *,lsampl_t *);
  int (*insn_write)(comedi_device *,comedi_subdevice *,comedi_insn *,lsampl_t *);
  int (*insn_bits)(comedi_device *,comedi_subdevice *,comedi_insn *,lsampl_t *);
  int (*insn_config)(comedi_device *,comedi_subdevice *,comedi_insn *,lsampl_t *);

  int (*do_cmd)(comedi_device *,comedi_subdevice *);
  int (*do_cmdtest)(comedi_device *,comedi_subdevice *,comedi_cmd *);
  int (*poll)(comedi_device *,comedi_subdevice *);
  int (*cancel)(comedi_device *,comedi_subdevice *);

  int (*buf_change)(comedi_device *,comedi_subdevice *s,unsigned long new_size);
  void (*munge)(comedi_device *, comedi_subdevice *s, void *data, unsigned int num_bytes, unsigned int start_chan_index );

  unsigned int state;
};

The function pointers insn_read … cancel . offer (pointers to) the standardized user-visible API that every subdevice should offer; every device driver has to fill in these functions with their board-specific implementations. (Functionality for which Comedi provides generic functions will, by definition, not show up in the device driver data structures.)

The buf_change and munge function pointers offer functionality that is not visible to the user and for which the device driver writer must provide a board-specific implementation: buf_change is called when a change in the data buffer requires handling; munge transforms different bit-representations of DAQ values, for example from unsigned to 2's complement.

The last data structure stores the information at the device level:

struct comedi_device_struct{
  int           use_count;
  comedi_driver *driver;
  void          *private;
  kdev_t        minor;
  char          *board_name;
  const void    *board_ptr;
  int           attached;
  int           rt;
  spinlock_t    spinlock;
  int           in_request_module;

  int               n_subdevices;
  comedi_subdevice *subdevices;
  int              options[COMEDI_NDEVCONFOPTS];

  /* dumb */
  int iobase;
  int irq;

  comedi_subdevice *read_subdev;
  wait_queue_head_t read_wait;

  comedi_subdevice *write_subdev;
  wait_queue_head_t write_wait;

  struct fasync_struct *async_queue;

  void (*open)(comedi_device *dev);
  void (*close)(comedi_device *dev);
};

The following data structure contains all relevant information: addresses and sizes of buffers, pointers to the actual data, and the information needed for event handling:

struct comedi_async_struct{
  void		*prealloc_buf;		/* pre-allocated buffer */
  unsigned int	prealloc_bufsz;		/* buffer size, in bytes */
  unsigned long	*buf_page_list;		/* physical address of each page */
  unsigned int	max_bufsize;		/* maximum buffer size, bytes */
  unsigned int	mmap_count;	/* current number of mmaps of prealloc_buf */

  volatile unsigned int buf_write_count;	/* byte count for writer (write completed) */
  volatile unsigned int buf_write_alloc_count;	/* byte count for writer (allocated for writing) */
  volatile unsigned int buf_read_count;	/* byte count for reader (read completed)*/

  unsigned int buf_write_ptr;	/* buffer marker for writer */
  unsigned int buf_read_ptr;	/* buffer marker for reader */

  unsigned int cur_chan;		/* useless channel marker for interrupt */
  /* number of bytes that have been received for current scan */
  unsigned int scan_progress;
  /* keeps track of where we are in chanlist as for munging */
  unsigned int munge_chan;

  unsigned int	events;		/* events that have occurred */

  comedi_cmd cmd;

  // callback stuff
  unsigned int cb_mask;
  int (*cb_func)(unsigned int flags,void *);
  void *cb_arg;

  int (*inttrig)(comedi_device *dev,comedi_subdevice *s,unsigned int x);
};

struct comedi_driver_struct{
	struct comedi_driver_struct *next;

	char *driver_name;
	struct module *module;
	int (*attach)(comedi_device *,comedi_devconfig *);
	int (*detach)(comedi_device *);

	/* number of elements in board_name and board_id arrays */
	unsigned int num_names;
	void *board_name;
	/* offset in bytes from one board name pointer to the next */
	int offset;
};