Changeset 352ac8d in multiio


Ignore:
Timestamp:
Jun 8, 2009, 6:40:06 PM (10 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
master
Children:
c99627b
Parents:
32eca41
Message:

2009-06-08 Joel Sherrill <joel.sherrill@…>

  • Makefile, mio_io.c, mio_io.h: Linux code split to porting file.
  • mio_io_linux.c: New file.
Location:
pcmmio/original
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed
  • pcmmio/original/ChangeLog

    r32eca41 r352ac8d  
     12009-06-08      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * Makefile, mio_io.c, mio_io.h: Linux code split to porting file.
     4        * mio_io_linux.c: New file.
     5
    162009-06-08      Joel Sherrill <joel.sherrill@oarcorp.com>
    27
  • pcmmio/original/Makefile

    r32eca41 r352ac8d  
    1717# C source names
    1818SHARED_CSRCS = rtems_config.c mio_io.c kbhit.c
     19SHARED_CSRCS += mio_io_linux.c
     20
    1921SHARED_COBJS = $(SHARED_CSRCS:%.c=${ARCH}/%.o)
    2022
  • pcmmio/original/mio_io.c

    r32eca41 r352ac8d  
    66*
    77*  $Log$
     8*  Revision 1.2  2009/06/08 18:21:56  joel
     9*  2009-06-08   Joel Sherrill <joel.sherrill@oarcorp.com>
     10*
     11*       * Makefile, kbhit.c, mio_io.c, mio_io.h: First successful compilation
     12*       under RTEMS. Added some Linux ifdef's.
     13*       * rtems_config.c: New file.
     14*
    815*  Revision 1.1.1.1  2009/06/08 14:52:43  joel
    916*  Initial import.
     
    1118*
    1219*  This file implements all of the supported 'C' language functions. Where necessary
    13 ioctl call are made into the kernel driver to access the actual hardware.
     20call are made into a porting layer to access the actual hardware.
    1421*/
    1522
     
    2128
    2229#include <stdio.h>
    23 #include <fcntl.h>      /* open */
    24 #include <unistd.h>     /* exit */
    25 #include <sys/ioctl.h>  /* ioctl */
    2630
    2731/* These image variable help out where a register is not
     
    7983
    8084
    81 
    82 /**************************************************************************
    83 *
    84 *               USER LIBRARY FUNCTIONS
    85 *
    86 ***************************************************************************
    87 */
    88 
    89 int handle = 0;
    90 char *device_id ="pcmmio";
    91 char *dev_id    = "/dev/pcmmio";
    9285
    9386///////////////////////////////////////////////////////////////////////////////
     
    347340///////////////////////////////////////////////////////////////////////////////
    348341//
    349 //              MIO_READ_IRQ_ASSIGNED
    350 //
    351 //////////////////////////////////////////////////////////////////////////////
    352 
    353 int mio_read_irq_assigned(void)
    354 {
    355 unsigned char val;
    356 
    357         mio_error_code = MIO_SUCCESS;
    358 
    359         if(check_handle())   /* Check for chip available */
    360                 return -1;
    361 
    362 
    363         /* All of our programming of the hardware is handled at this level so that
    364            all of the routines that need to shove and IRQ value into hardware will
    365            use this call.
    366    */
    367 
    368     val = ioctl(handle,READ_IRQ_ASSIGNED,NULL);
    369 
    370         return val & 0xff;
    371 }
    372 
    373 
    374 ///////////////////////////////////////////////////////////////////////////////
    375 //
    376342//              SET_DAC_SPAN
    377343//
     
    479445int set_dac_voltage(int channel, float voltage)
    480446{
    481 unsigned short  value;
     447unsigned short  value = 0;
    482448float bit_val;
    483449
     
    547513        return 0;
    548514}
    549 
    550 ///////////////////////////////////////////////////////////////////////////////
    551 //
    552 //              READ_DIO_BYTE
    553 //
    554 //////////////////////////////////////////////////////////////////////////////
    555 
    556 unsigned char read_dio_byte(int offset)
    557 {
    558 int val;
    559 
    560         mio_error_code = MIO_SUCCESS;
    561 
    562         if(check_handle())   /* Check for chip available */
    563                 return -1;
    564 
    565         /* All bit operations are handled at this level so we need only
    566         read and write bytes from the actual hardware using the driver
    567         to handle our ioctl call for it.
    568         */
    569 
    570     val = ioctl(handle,READ_DIO_BYTE,offset);
    571 
    572         return (unsigned char) (val & 0xff);;
    573 }
    574 
    575 ///////////////////////////////////////////////////////////////////////////////
    576 //
    577 //              MIO_READ_REG
    578 //
    579 //////////////////////////////////////////////////////////////////////////////
    580 
    581 unsigned char mio_read_reg(int offset)
    582 {
    583 int val;
    584 
    585         mio_error_code = MIO_SUCCESS;
    586 
    587         if(check_handle())   /* Check for chip available */
    588                 return -1;
    589 
    590 
    591         /* This is a catchall register read routine that allows reading of
    592            ANY of the registers on the PCM-MIO. It is used primarily for
    593            retreiving control and access values in the hardware.
    594    */
    595 
    596      val = ioctl(handle,MIO_READ_REG,offset);
    597 
    598         return (unsigned char) (val & 0xff);
    599 }
    600 
    601 ///////////////////////////////////////////////////////////////////////////////
    602 //
    603 //              MIO_WRITE_REG
    604 //
    605 //////////////////////////////////////////////////////////////////////////////
    606 
    607 int mio_write_reg(int offset, unsigned char value)
    608 {
    609 unsigned short param;
    610 int val;
    611 
    612         mio_error_code = MIO_SUCCESS;
    613 
    614         if(check_handle())   /* Check for chip available */
    615                 return -1;
    616 
    617         param = offset & 0xff;
    618 
    619         param = param | (value << 8);
    620    
    621         /* This function like the previous allow unlimited
    622            write access to ALL of the registers on the PCM-MIO
    623    */
    624 
    625         val = ioctl(handle,MIO_WRITE_REG,param);
    626        
    627         return 0;
    628 }
    629 
    630 
    631 ///////////////////////////////////////////////////////////////////////////////
    632 //
    633 //              WRITE_DIO_BYTE
    634 //
    635 //////////////////////////////////////////////////////////////////////////////
    636 
    637 int write_dio_byte(int offset, unsigned char value)
    638 {
    639 unsigned short param;
    640 int val;
    641 
    642         mio_error_code = MIO_SUCCESS;
    643 
    644         if(check_handle())   /* Check for chip available */
    645                 return -1;
    646 
    647         param = offset & 0xff;
    648 
    649         param = param | (value << 8);
    650    
    651         /* All bit operations for the DIO are handled at this level
    652            and we need the driver to allow access to the actual
    653            DIO registers to update the value.
    654     */
    655 
    656         val = ioctl(handle,WRITE_DIO_BYTE,param);
    657        
    658         return 0;
    659 }
    660 
    661 
    662 ///////////////////////////////////////////////////////////////////////////////
    663 //
    664 //              WRITE_DAC_COMMAND
    665 //
    666 //////////////////////////////////////////////////////////////////////////////
    667 
    668 int write_dac_command(int dac_num,unsigned char value)
    669 {
    670 unsigned short param;
    671 int val;
    672 
    673         mio_error_code = MIO_SUCCESS;
    674 
    675         if(check_handle())   /* Check for chip available */
    676                 return -1;
    677 
    678         param = dac_num & 0xff;
    679 
    680         param = param | (value << 8);
    681 
    682         val = ioctl(handle,WRITE_DAC_COMMAND,param);
    683 
    684         return 0;
    685 }
    686 
    687515
    688516///////////////////////////////////////////////////////////////////////////////
     
    1127955///////////////////////////////////////////////////////////////////////////////
    1128956//
    1129 //              WRITE_ADC_COMMAND
    1130 //
    1131 //////////////////////////////////////////////////////////////////////////////
    1132 
    1133 int write_adc_command(int adc_num,unsigned char value)
    1134 {
    1135 unsigned short param;
    1136 int ret_val;
    1137 
    1138         mio_error_code = MIO_SUCCESS;
    1139 
    1140         if(check_handle())   /* Check for chip available */
    1141                 return -1;
    1142 
    1143         param = adc_num & 0xff;
    1144 
    1145         param = param | (value << 8);
    1146 
    1147     ret_val = ioctl(handle,WRITE_ADC_COMMAND,param);
    1148 
    1149         return 0;
    1150 }
    1151 
    1152 ///////////////////////////////////////////////////////////////////////////////
    1153 //
    1154957//              BUFFERED_DAC_OUTPUT
    1155958//
     
    1175978                x++;
    1176979        }
    1177 }
    1178 
    1179 ///////////////////////////////////////////////////////////////////////////////
    1180 //
    1181 //              WRITE_DAC_DATA
    1182 //
    1183 //////////////////////////////////////////////////////////////////////////////
    1184 
    1185 int write_dac_data(int dac_num, unsigned short value)
    1186 {
    1187 int ret_val;
    1188 unsigned char buffer[3];
    1189 
    1190         mio_error_code = MIO_SUCCESS;
    1191 
    1192         if(check_handle())   /* Check for chip available */
    1193                 return -1;
    1194 
    1195         buffer[0] = dac_num;
    1196         buffer[1] = value & 0xff;
    1197         buffer[2] = value >> 8;
    1198 
    1199     ret_val = ioctl(handle,WRITE_DAC_DATA,buffer);
    1200        
    1201         return 0;
    1202 }
    1203 
    1204 ///////////////////////////////////////////////////////////////////////////////
    1205 //
    1206 //              DAC_READ_STATUS
    1207 //
    1208 //////////////////////////////////////////////////////////////////////////////
    1209 
    1210 unsigned char dac_read_status(int dac_num)
    1211 {
    1212 int ret_val;
    1213 
    1214         mio_error_code = MIO_SUCCESS;
    1215 
    1216         if(check_handle())   /* Check for chip available */
    1217                 return -1;
    1218 
    1219     ret_val = ioctl(handle,READ_DAC_STATUS,dac_num);
    1220 
    1221         return ret_val & 0xff;
    1222 }
    1223 
    1224 ///////////////////////////////////////////////////////////////////////////////
    1225 //
    1226 //              ADC_READ_STATUS
    1227 //
    1228 //////////////////////////////////////////////////////////////////////////////
    1229 
    1230 unsigned char adc_read_status(int adc_num)
    1231 {
    1232 int ret_val;
    1233 
    1234         mio_error_code = MIO_SUCCESS;
    1235 
    1236         if(check_handle())   /* Check for chip available */
    1237                 return -1;
    1238 
    1239     ret_val = ioctl(handle,READ_ADC_STATUS,adc_num);
    1240 
    1241         return (ret_val & 0xff);
    1242980}
    1243981
     
    13321070}
    13331071
    1334 ///////////////////////////////////////////////////////////////////////////////
    1335 //
    1336 //              ADC_READ_CONVERSION_DATA
    1337 //
    1338 //////////////////////////////////////////////////////////////////////////////
    1339 
    1340 unsigned short adc_read_conversion_data(int channel)
    1341 {
    1342 int ret_val;
    1343 int adc_num;
    1344 
    1345         mio_error_code = MIO_SUCCESS;
    1346 
    1347         if(check_handle())   /* Check for chip available */
    1348                 return -1;
    1349 
    1350         if(channel > 7)
    1351                 adc_num = 1;
    1352         else
    1353                 adc_num = 0;
    1354 
    1355     ret_val = ioctl(handle,READ_ADC_DATA,adc_num);
    1356        
    1357         return (ret_val & 0xffff);
    1358 }
    1359 
    1360 
    13611072////////////////////////////////////////////////////////////////////////////////
    13621073//
     
    17971508}
    17981509
    1799 
    1800 int dio_get_int(void)
    1801 {
    1802 int c;
    1803 
    1804     c=ioctl(handle,DIO_GET_INT,NULL);
    1805 
    1806     return (c & 0xff);
    1807 
    1808 }
    1809 
    1810 
    1811 int wait_adc_int(int adc_num)
    1812 {
    1813 int c;
    1814 
    1815 
    1816     if(check_handle())   /* Check for chip available */
    1817                 return -1;
    1818 
    1819         if(adc_num)
    1820             c=ioctl(handle,WAIT_A2D_INT_1,NULL);
    1821         else
    1822             c=ioctl(handle,WAIT_A2D_INT_2,NULL);
    1823 
    1824 
    1825     return (c & 0xff);
    1826 
    1827 }
    1828 
    1829 
    1830 int wait_dac_int(int dac_num)
    1831 {
    1832 int c;
    1833 
    1834     if(check_handle())   /* Check for chip available */
    1835                 return -1;
    1836 
    1837         if(dac_num)
    1838             c=ioctl(handle,WAIT_DAC_INT_1,NULL);
    1839         else
    1840             c=ioctl(handle,WAIT_DAC_INT_2,NULL);
    1841 
    1842     return (c & 0xff);
    1843 
    1844 }
    1845 
    1846 
    1847 int wait_dio_int(void)
    1848 {
    1849 int c;
    1850 
    1851 
    1852     if(check_handle())   /* Check for chip available */
    1853                 return -1;
    1854 
    1855     c=ioctl(handle,WAIT_DIO_INT,NULL);
    1856 
    1857     return (c & 0xff);
    1858 
    1859 }
    1860 
    1861 
    1862 
    1863 int check_handle(void)
    1864 {
    1865     if(handle > 0)      /* If it's already a valid handle */
    1866                 return 0;
    1867 
    1868     if(handle == -1)    /* If it's already been tried */
    1869         {
    1870                 mio_error_code = MIO_OPEN_ERROR;
    1871                 sprintf(mio_error_string,"MIO - Unable to open device PCMMIO");
    1872                 return -1;
    1873         }
    1874 
    1875     /* Try opening the device file, in case it hasn't been opened yet */
    1876 
    1877     handle = open(device_id,0);
    1878 
    1879         /* Try an alternate open at /dev */
    1880 
    1881         if(handle < 0)
    1882                 handle = open(dev_id,0);
    1883 
    1884     if(handle > 0)      /* If it's now a valid handle */
    1885                 return 0;
    1886 
    1887         mio_error_code = MIO_OPEN_ERROR;
    1888         sprintf(mio_error_string,"MIO - Unable to open device PCMMIO");
    1889     handle = -1;
    1890         return -1;
    1891 }
    1892 
  • pcmmio/original/mio_io.h

    r32eca41 r352ac8d  
    88
    99/* $Log$
     10 * Revision 1.2  2009/06/08 18:21:56  joel
     11 * 2009-06-08   Joel Sherrill <joel.sherrill@oarcorp.com>
     12 *
     13 *      * Makefile, kbhit.c, mio_io.c, mio_io.h: First successful compilation
     14 *      under RTEMS. Added some Linux ifdef's.
     15 *      * rtems_config.c: New file.
     16 *
    1017 * Revision 1.1.1.1  2009/06/08 14:52:43  joel
    1118 * Initial import.
     
    124131char mio_error_string[128];
    125132float adc_bitval[16] = {.00, .00, .00, .00, .00, .00, 00, .00,
    126                                                            .00, .00, .00, .00, .00, .00, .00, .00 };
     133                        .00, .00, .00, .00, .00, .00, .00, .00 };
    127134
    128135unsigned short adc_adjust[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
    129136
    130137float adc_offset[16] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
    131                                                 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
     138                        0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
    132139
    133140#else
     
    149156#endif
    150157
     158/* part of the porting layer */
     159int check_handle(void);
     160int mio_read_irq_assigned(void);
    151161
    152162int disable_dio_interrupt(void);
Note: See TracChangeset for help on using the changeset viewer.