api/gpio__avr_8c_source.html

00001
00037 #include <arch/avr.h>
00038
00039 #include <stdlib.h>
00040 #include <string.h>
00041
00042 #include <dev/gpio.h>
00043
00044 int GpioPinGet(int bank, int bit)
00045 {
00046     switch(bank) {
00047 #ifdef PINA
00048     case AVRPORTA:
00049         return bit_is_set(PINA, bit) != 0;
00050 #endif
00051 #ifdef PINB
00052     case AVRPORTB:
00053         return bit_is_set(PINB, bit) != 0;
00054 #endif
00055 #ifdef PINC
00056     case AVRPORTC:
00057         return bit_is_set(PINC, bit) != 0;
00058 #endif
00059 #ifdef PIND
00060     case AVRPORTD:
00061         return bit_is_set(PIND, bit) != 0;
00062 #endif
00063 #ifdef PINE
00064     case AVRPORTE:
00065         return bit_is_set(PINE, bit) != 0;
00066 #endif
00067 #ifdef PINF
00068     case AVRPORTF:
00069         return bit_is_set(PINF, bit) != 0;
00070 #endif
00071 #ifdef PING
00072     case AVRPORTG:
00073         return bit_is_set(PING, bit) != 0;
00074 #endif
00075 #ifdef PINH
00076     case AVRPORTH:
00077         return bit_is_set(PINH, bit) != 0;
00078 #endif
00079 #ifdef PINI
00080     case AVRPORTI:
00081         return bit_is_set(PINI, bit) != 0;
00082 #endif
00083 #ifdef PINJ
00084     case AVRPORTJ:
00085         return bit_is_set(PINJ, bit) != 0;
00086 #endif
00087 #ifdef PINK
00088     case AVRPORTK:
00089         return bit_is_set(PINK, bit) != 0;
00090 #endif
00091 #ifdef PINL
00092     case AVRPORTL:
00093         return bit_is_set(PINL, bit) != 0;
00094 #endif
00095     }
00096     return 0;
00097 }
00098
00099 void GpioPinSetLow(int bank, int bit)
00100 {
00101     switch(bank) {
00102 #ifdef PORTA
00103     case AVRPORTA:
00104         cbi(PORTA, bit);
00105         break;
00106 #endif
00107 #ifdef PORTB
00108     case AVRPORTB:
00109         cbi(PORTB, bit);
00110         break;
00111 #endif
00112 #ifdef PORTC
00113     case AVRPORTC:
00114         cbi(PORTC, bit);
00115         break;
00116 #endif
00117 #ifdef PORTD
00118     case AVRPORTD:
00119         cbi(PORTD, bit);
00120         break;
00121 #endif
00122 #ifdef PORTE
00123     case AVRPORTE:
00124         cbi(PORTE, bit);
00125         break;
00126 #endif
00127 #ifdef PORTF
00128     case AVRPORTF:
00129         cbi(PORTF, bit);
00130         break;
00131 #endif
00132 #ifdef PORTG
00133     case AVRPORTG:
00134         cbi(PORTG, bit);
00135         break;
00136 #endif
00137 #ifdef PORTH
00138     case AVRPORTH:
00139         cbi(PORTH, bit);
00140         break;
00141 #endif
00142 #ifdef PORTI
00143     case AVRPORTI:
00144         cbi(PORTI, bit);
00145         break;
00146 #endif
00147 #ifdef PORTJ
00148     case AVRPORTJ:
00149         cbi(PORTJ, bit);
00150         break;
00151 #endif
00152 #ifdef PORTK
00153     case AVRPORTK:
00154         cbi(PORTK, bit);
00155         break;
00156 #endif
00157 #ifdef PORTL
00158     case AVRPORTL:
00159         cbi(PORTL, bit);
00160         break;
00161 #endif
00162     }
00163 }
00164
00165 void GpioPinSetHigh(int bank, int bit)
00166 {
00167     switch(bank) {
00168 #ifdef PORTA
00169     case AVRPORTA:
00170         sbi(PORTA, bit);
00171         break;
00172 #endif
00173 #ifdef PORTB
00174     case AVRPORTB:
00175         sbi(PORTB, bit);
00176         break;
00177 #endif
00178 #ifdef PORTC
00179     case AVRPORTC:
00180         sbi(PORTC, bit);
00181         break;
00182 #endif
00183 #ifdef PORTD
00184     case AVRPORTD:
00185         sbi(PORTD, bit);
00186         break;
00187 #endif
00188 #ifdef PORTE
00189     case AVRPORTE:
00190         sbi(PORTE, bit);
00191         break;
00192 #endif
00193 #ifdef PORTF
00194     case AVRPORTF:
00195         sbi(PORTF, bit);
00196         break;
00197 #endif
00198 #ifdef PORTG
00199     case AVRPORTG:
00200         sbi(PORTG, bit);
00201         break;
00202 #endif
00203 #ifdef PORTH
00204     case AVRPORTH:
00205         sbi(PORTH, bit);
00206         break;
00207 #endif
00208 #ifdef PORTI
00209     case AVRPORTI:
00210         sbi(PORTI, bit);
00211         break;
00212 #endif
00213 #ifdef PORTJ
00214     case AVRPORTJ:
00215         sbi(PORTJ, bit);
00216         break;
00217 #endif
00218 #ifdef PORTK
00219     case AVRPORTK:
00220         sbi(PORTK, bit);
00221         break;
00222 #endif
00223 #ifdef PORTL
00224     case AVRPORTL:
00225         sbi(PORTL, bit);
00226         break;
00227 #endif
00228     }
00229 }
00230
00231 void GpioPinSet(int bank, int bit, int value)
00232 {
00233     if (value) {
00234         GpioPinSetHigh(bank, bit);
00235     }
00236     else {
00237         GpioPinSetLow(bank, bit);
00238     }
00239 }
00240
00241 unsigned int GpioPortGet(int bank)
00242 {
00243     switch(bank) {
00244 #ifdef PINA
00245     case AVRPORTA:
00246         return inb(PINA);
00247 #endif
00248 #ifdef PINB
00249     case AVRPORTB:
00250         return inb(PINB);
00251 #endif
00252 #ifdef PINC
00253     case AVRPORTC:
00254         return inb(PINC);
00255 #endif
00256 #ifdef PIND
00257     case AVRPORTD:
00258         return inb(PIND);
00259 #endif
00260 #ifdef PINE
00261     case AVRPORTE:
00262         return inb(PINE);
00263 #endif
00264 #ifdef PINF
00265     case AVRPORTF:
00266         return inb(PINF);
00267 #endif
00268 #ifdef PING
00269     case AVRPORTG:
00270         return inb(PING);
00271 #endif
00272 #ifdef PINH
00273     case AVRPORTH:
00274         return inb(PINH);
00275 #endif
00276 #ifdef PINI
00277     case AVRPORTI:
00278         return inb(PINI);
00279 #endif
00280 #ifdef PINJ
00281     case AVRPORTJ:
00282         return inb(PINJ);
00283 #endif
00284 #ifdef PINK
00285     case AVRPORTK:
00286         return inb(PINK);
00287 #endif
00288 #ifdef PINL
00289     case AVRPORTL:
00290         return inb(PINL);
00291 #endif
00292     }
00293     return 0;
00294 }
00295
00296 void GpioPortSet(int bank, unsigned int value)
00297 {
00298     switch(bank) {
00299 #ifdef PORTA
00300     case AVRPORTA:
00301         outb(PORTA, (uint8_t)value);
00302         break;
00303 #endif
00304 #ifdef PORTB
00305     case AVRPORTB:
00306         outb(PORTB, (uint8_t)value);
00307         break;
00308 #endif
00309 #ifdef PORTC
00310     case AVRPORTC:
00311         outb(PORTC, (uint8_t)value);
00312         break;
00313 #endif
00314 #ifdef PORTD
00315     case AVRPORTD:
00316         outb(PORTD, (uint8_t)value);
00317         break;
00318 #endif
00319 #ifdef PORTE
00320     case AVRPORTE:
00321         outb(PORTE, (uint8_t)value);
00322         break;
00323 #endif
00324 #ifdef PORTF
00325     case AVRPORTF:
00326         outb(PORTF, (uint8_t)value);
00327         break;
00328 #endif
00329 #ifdef PORTG
00330     case AVRPORTG:
00331         outb(PORTG, (uint8_t)value);
00332         break;
00333 #endif
00334 #ifdef PORTH
00335     case AVRPORTH:
00336         outb(PORTH, (uint8_t)value);
00337         break;
00338 #endif
00339 #ifdef PORTI
00340     case AVRPORTI:
00341         outb(PORTI, (uint8_t)value);
00342         break;
00343 #endif
00344 #ifdef PORTJ
00345     case AVRPORTJ:
00346         outb(PORTJ, (uint8_t)value);
00347         break;
00348 #endif
00349 #ifdef PORTK
00350     case AVRPORTK:
00351         outb(PORTK, (uint8_t)value);
00352         break;
00353 #endif
00354 #ifdef PORTL
00355     case AVRPORTL:
00356         outb(PORTL, (uint8_t)value);
00357         break;
00358 #endif
00359     }
00360 }
00361
00362 void GpioPortSetLow(int bank, unsigned int mask)
00363 {
00364     GpioPortSet(bank, GpioPortGet(bank) & ~mask);
00365 }
00366
00367 void GpioPortSetHigh(int bank, unsigned int mask)
00368 {
00369     GpioPortSet(bank, GpioPortGet(bank) | mask);
00370 }
00371
00372 uint32_t GpioPinConfigGet(int bank, int bit)
00373 {
00374     uint32_t rc = 0;
00375
00376     switch(bank) {
00377 #ifdef DDRA
00378     case AVRPORTA:
00379         if (inb(DDRA) & _BV(bit)) {
00380             rc |= GPIO_CFG_OUTPUT;
00381         }
00382         else if (inb(PORTA) & _BV(bit)) {
00383             rc |= GPIO_CFG_PULLUP;
00384         }
00385         break;
00386 #endif
00387 #ifdef DDRB
00388     case AVRPORTB:
00389         if (inb(DDRB) & _BV(bit)) {
00390             rc |= GPIO_CFG_OUTPUT;
00391         }
00392         else if (inb(PORTB) & _BV(bit)) {
00393             rc |= GPIO_CFG_PULLUP;
00394         }
00395         break;
00396 #endif
00397 #ifdef DDRC
00398     case AVRPORTC:
00399         if (inb(DDRC) & _BV(bit)) {
00400             rc |= GPIO_CFG_OUTPUT;
00401         }
00402         else if (inb(PORTC) & _BV(bit)) {
00403             rc |= GPIO_CFG_PULLUP;
00404         }
00405         break;
00406 #endif
00407 #ifdef DDRD
00408     case AVRPORTD:
00409         if (inb(DDRD) & _BV(bit)) {
00410             rc |= GPIO_CFG_OUTPUT;
00411         }
00412         else if (inb(PORTD) & _BV(bit)) {
00413             rc |= GPIO_CFG_PULLUP;
00414         }
00415         break;
00416 #endif
00417 #ifdef DDRE
00418     case AVRPORTE:
00419         if (inb(DDRE) & _BV(bit)) {
00420             rc |= GPIO_CFG_OUTPUT;
00421         }
00422         else if (inb(PORTE) & _BV(bit)) {
00423             rc |= GPIO_CFG_PULLUP;
00424         }
00425         break;
00426 #endif
00427 #ifdef DDRF
00428     case AVRPORTF:
00429         if (inb(DDRF) & _BV(bit)) {
00430             rc |= GPIO_CFG_OUTPUT;
00431         }
00432         else if (inb(PORTF) & _BV(bit)) {
00433             rc |= GPIO_CFG_PULLUP;
00434         }
00435         break;
00436 #endif
00437 #ifdef DDRG
00438     case AVRPORTG:
00439         if (inb(DDRG) & _BV(bit)) {
00440             rc |= GPIO_CFG_OUTPUT;
00441         }
00442         else if (inb(PORTG) & _BV(bit)) {
00443             rc |= GPIO_CFG_PULLUP;
00444         }
00445         break;
00446 #endif
00447 #ifdef DDRH
00448     case AVRPORTH:
00449         if (inb(DDRH) & _BV(bit)) {
00450             rc |= GPIO_CFG_OUTPUT;
00451         }
00452         else if (inb(PORTH) & _BV(bit)) {
00453             rc |= GPIO_CFG_PULLUP;
00454         }
00455         break;
00456 #endif
00457 #ifdef DDRI
00458     case AVRPORTI:
00459         if (inb(DDRI) & _BV(bit)) {
00460             rc |= GPIO_CFG_OUTPUT;
00461         }
00462         else if (inb(PORTI) & _BV(bit)) {
00463             rc |= GPIO_CFG_PULLUP;
00464         }
00465         break;
00466 #endif
00467 #ifdef DDRJ
00468     case AVRPORTJ:
00469         if (inb(DDRJ) & _BV(bit)) {
00470             rc |= GPIO_CFG_OUTPUT;
00471         }
00472         else if (inb(PORTJ) & _BV(bit)) {
00473             rc |= GPIO_CFG_PULLUP;
00474         }
00475         break;
00476 #endif
00477 #ifdef DDRK
00478     case AVRPORTK:
00479         if (inb(DDRK) & _BV(bit)) {
00480             rc |= GPIO_CFG_OUTPUT;
00481         }
00482         else if (inb(PORTK) & _BV(bit)) {
00483             rc |= GPIO_CFG_PULLUP;
00484         }
00485         break;
00486 #endif
00487 #ifdef DDRL
00488     case AVRPORTL:
00489         if (inb(DDRL) & _BV(bit)) {
00490             rc |= GPIO_CFG_OUTPUT;
00491         }
00492         else if (inb(PORTL) & _BV(bit)) {
00493             rc |= GPIO_CFG_PULLUP;
00494         }
00495         break;
00496 #endif
00497     }
00498     return rc;
00499 }
00500
00501 int GpioPortConfigSet(int bank, unsigned int mask, uint32_t flags)
00502 {
00503     switch(bank) {
00504 #ifdef DDRA
00505     case AVRPORTA:
00506         if (flags & GPIO_CFG_PULLUP) {
00507             outb(PORTA, inb(PORTA) | mask);
00508         }
00509         else {
00510             outb(PORTA, inb(PORTA) & ~mask);
00511         }
00512         if (flags & GPIO_CFG_OUTPUT) {
00513             outb(DDRA, inb(DDRA) | mask);
00514         }
00515         else {
00516             outb(DDRA, inb(DDRA) & ~mask);
00517         }
00518         break;
00519 #endif
00520 #ifdef DDRB
00521     case AVRPORTB:
00522         if (flags & GPIO_CFG_PULLUP) {
00523             outb(PORTB, inb(PORTB) | mask);
00524         }
00525         else {
00526             outb(PORTB, inb(PORTB) & ~mask);
00527         }
00528         if (flags & GPIO_CFG_OUTPUT) {
00529             outb(DDRB, inb(DDRB) | mask);
00530         }
00531         else {
00532             outb(DDRB, inb(DDRB) & ~mask);
00533         }
00534         break;
00535 #endif
00536 #ifdef DDRC
00537     case AVRPORTC:
00538         if (flags & GPIO_CFG_PULLUP) {
00539             outb(PORTC, inb(PORTC) | mask);
00540         }
00541         else {
00542             outb(PORTC, inb(PORTC) & ~mask);
00543         }
00544         if (flags & GPIO_CFG_OUTPUT) {
00545             outb(DDRC, inb(DDRC) | mask);
00546         }
00547         else {
00548             outb(DDRC, inb(DDRC) & ~mask);
00549         }
00550         break;
00551 #endif
00552 #ifdef DDRD
00553     case AVRPORTD:
00554         if (flags & GPIO_CFG_PULLUP) {
00555             outb(PORTD, inb(PORTD) | mask);
00556         }
00557         else {
00558             outb(PORTD, inb(PORTD) & ~mask);
00559         }
00560         if (flags & GPIO_CFG_OUTPUT) {
00561             outb(DDRD, inb(DDRD) | mask);
00562         }
00563         else {
00564             outb(DDRD, inb(DDRD) & ~mask);
00565         }
00566         break;
00567 #endif
00568 #ifdef DDRE
00569     case AVRPORTE:
00570         if (flags & GPIO_CFG_PULLUP) {
00571             outb(PORTE, inb(PORTE) | mask);
00572         }
00573         else {
00574             outb(PORTE, inb(PORTE) & ~mask);
00575         }
00576         if (flags & GPIO_CFG_OUTPUT) {
00577             outb(DDRE, inb(DDRE) | mask);
00578         }
00579         else {
00580             outb(DDRE, inb(DDRE) & ~mask);
00581         }
00582         break;
00583 #endif
00584 #ifdef DDRF
00585     case AVRPORTF:
00586         if (flags & GPIO_CFG_PULLUP) {
00587             outb(PORTF, inb(PORTF) | mask);
00588         }
00589         else {
00590             outb(PORTF, inb(PORTF) & ~mask);
00591         }
00592         if (flags & GPIO_CFG_OUTPUT) {
00593             outb(DDRF, inb(DDRF) | mask);
00594         }
00595         else {
00596             outb(DDRF, inb(DDRF) & ~mask);
00597         }
00598         break;
00599 #endif
00600 #ifdef DDRG
00601     case AVRPORTG:
00602         if (flags & GPIO_CFG_PULLUP) {
00603             outb(PORTG, inb(PORTG) | mask);
00604         }
00605         else {
00606             outb(PORTG, inb(PORTG) & ~mask);
00607         }
00608         if (flags & GPIO_CFG_OUTPUT) {
00609             outb(DDRG, inb(DDRG) | mask);
00610         }
00611         else {
00612             outb(DDRG, inb(DDRG) & ~mask);
00613         }
00614         break;
00615 #endif
00616 #ifdef DDRH
00617     case AVRPORTH:
00618         if (flags & GPIO_CFG_PULLUP) {
00619             outb(PORTH, inb(PORTH) | mask);
00620         }
00621         else {
00622             outb(PORTH, inb(PORTH) & ~mask);
00623         }
00624         if (flags & GPIO_CFG_OUTPUT) {
00625             outb(DDRH, inb(DDRH) | mask);
00626         }
00627         else {
00628             outb(DDRH, inb(DDRH) & ~mask);
00629         }
00630         break;
00631 #endif
00632 #ifdef DDRI
00633     case AVRPORTI:
00634         if (flags & GPIO_CFG_PULLUP) {
00635             outb(PORTI, inb(PORTI) | mask);
00636         }
00637         else {
00638             outb(PORTI, inb(PORTI) & ~mask);
00639         }
00640         if (flags & GPIO_CFG_OUTPUT) {
00641             outb(DDRI, inb(DDRI) | mask);
00642         }
00643         else {
00644             outb(DDRI, inb(DDRI) & ~mask);
00645         }
00646         break;
00647 #endif
00648 #ifdef DDRJ
00649     case AVRPORTJ:
00650         if (flags & GPIO_CFG_PULLUP) {
00651             outb(PORTJ, inb(PORTJ) | mask);
00652         }
00653         else {
00654             outb(PORTJ, inb(PORTJ) & ~mask);
00655         }
00656         if (flags & GPIO_CFG_OUTPUT) {
00657             outb(DDRJ, inb(DDRJ) | mask);
00658         }
00659         else {
00660             outb(DDRJ, inb(DDRJ) & ~mask);
00661         }
00662         break;
00663 #endif
00664 #ifdef DDRK
00665     case AVRPORTK:
00666         if (flags & GPIO_CFG_PULLUP) {
00667             outb(PORTK, inb(PORTK) | mask);
00668         }
00669         else {
00670             outb(PORTK, inb(PORTK) & ~mask);
00671         }
00672         if (flags & GPIO_CFG_OUTPUT) {
00673             outb(DDRK, inb(DDRK) | mask);
00674         }
00675         else {
00676             outb(DDRK, inb(DDRK) & ~mask);
00677         }
00678         break;
00679 #endif
00680 #ifdef DDRL
00681     case AVRPORTL:
00682         if (flags & GPIO_CFG_PULLUP) {
00683             outb(PORTL, inb(PORTL) | mask);
00684         }
00685         else {
00686             outb(PORTL, inb(PORTL) & ~mask);
00687         }
00688         if (flags & GPIO_CFG_OUTPUT) {
00689             outb(DDRL, inb(DDRL) | mask);
00690         }
00691         else {
00692             outb(DDRL, inb(DDRL) & ~mask);
00693         }
00694         break;
00695 #endif
00696     }
00697     return 0;
00698 }
00699
00700 int GpioPinConfigSet(int bank, int bit, uint32_t flags)
00701 {
00702     switch(bank) {
00703 #ifdef DDRA
00704     case AVRPORTA:
00705         if (flags & GPIO_CFG_OUTPUT) {
00706             sbi(DDRA, bit);
00707         }
00708         else {
00709             if (flags & GPIO_CFG_PULLUP) {
00710                 sbi(PORTA, bit);
00711             }
00712             else {
00713                 cbi(PORTA, bit);
00714             }
00715             cbi(DDRA, bit);
00716         }
00717         break;
00718 #endif
00719 #ifdef DDRB
00720     case AVRPORTB:
00721         if (flags & GPIO_CFG_OUTPUT) {
00722             sbi(DDRB, bit);
00723         }
00724         else {
00725             if (flags & GPIO_CFG_PULLUP) {
00726                 sbi(PORTB, bit);
00727             }
00728             else {
00729                 cbi(PORTB, bit);
00730             }
00731             cbi(DDRB, bit);
00732         }
00733         break;
00734 #endif
00735 #ifdef DDRC
00736     case AVRPORTC:
00737         if (flags & GPIO_CFG_OUTPUT) {
00738             sbi(DDRC, bit);
00739         }
00740         else {
00741             if (flags & GPIO_CFG_PULLUP) {
00742                 sbi(PORTC, bit);
00743             }
00744             else {
00745                 cbi(PORTC, bit);
00746             }
00747             cbi(DDRC, bit);
00748         }
00749         break;
00750 #endif
00751 #ifdef DDRD
00752     case AVRPORTD:
00753         if (flags & GPIO_CFG_OUTPUT) {
00754             sbi(DDRD, bit);
00755         }
00756         else {
00757             if (flags & GPIO_CFG_PULLUP) {
00758                 sbi(PORTD, bit);
00759             }
00760             else {
00761                 cbi(PORTD, bit);
00762             }
00763             cbi(DDRD, bit);
00764         }
00765         break;
00766 #endif
00767 #ifdef DDRE
00768     case AVRPORTE:
00769         if (flags & GPIO_CFG_OUTPUT) {
00770             sbi(DDRE, bit);
00771         }
00772         else {
00773             if (flags & GPIO_CFG_PULLUP) {
00774                 sbi(PORTE, bit);
00775             }
00776             else {
00777                 cbi(PORTE, bit);
00778             }
00779             cbi(DDRE, bit);
00780         }
00781         break;
00782 #endif
00783 #ifdef DDRF
00784     case AVRPORTF:
00785         if (flags & GPIO_CFG_OUTPUT) {
00786             sbi(DDRF, bit);
00787         }
00788         else {
00789             if (flags & GPIO_CFG_PULLUP) {
00790                 sbi(PORTF, bit);
00791             }
00792             else {
00793                 cbi(PORTF, bit);
00794             }
00795             cbi(DDRF, bit);
00796         }
00797         break;
00798 #endif
00799     default:
00800         /* Use port wide function for registers above I/O space. */
00801         GpioPortConfigSet(bank, _BV(bit), flags);
00802         break;
00803     }
00804
00805     /* Check the result. */
00806     if (GpioPinConfigGet(bank, bit) != flags) {
00807         return -1;
00808     }
00809     return 0;
00810 }
00811
00812 int GpioRegisterIrqHandler(GPIO_SIGNAL * sig, int bit, void (*handler) (void *), void *arg)
00813 {
00814     return -1;
00815 }
00816
00817 int GpioIrqEnable(GPIO_SIGNAL * sig, int bit)
00818 {
00819     return -1;
00820 }
00821
00822 int GpioIrqDisable(GPIO_SIGNAL * sig, int bit)
00823 {
00824     return -1;
00825 }