git.gag.com Git - fw/altos/blob - ccdbg-io.c

   1 /*
   2  * Copyright © 2008 Keith Packard <keithp@keithp.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  17  */
  18
  19 #include "ccdbg.h"
  20
  21 void
  22 ccdbg_quarter_clock(struct ccdbg *dbg)
  23 {
  24         usleep(CC_CLOCK_US / 4);
  25 }
  26
  27 struct ccdbg *
  28 ccdbg_open(char *file)
  29 {
  30         struct ccdbg *dbg;
  31
  32         dbg = calloc(sizeof (struct ccdbg), 1);
  33         if (!dbg) {
  34                 perror("calloc");
  35                 return NULL;
  36         }
  37         dbg->fd = open(file, 2);
  38         if (dbg->fd < 0) {
  39                 perror(file);
  40                 free(dbg);
  41                 return NULL;
  42         }
  43         cccp_init(dbg);
  44         return dbg;
  45 }
  46
  47 void
  48 ccdbg_clock_1_0(struct ccdbg *dbg)
  49 {
  50         ccdbg_quarter_clock(dbg);
  51         assert(dbg->clock == 1);
  52         cccp_write(dbg, CC_CLOCK, 0);
  53         dbg->clock = 0;
  54         ccdbg_quarter_clock(dbg);
  55 }
  56
  57 void
  58 ccdbg_clock_0_1(struct ccdbg *dbg)
  59 {
  60         ccdbg_quarter_clock(dbg);
  61         assert(dbg->clock == 0);
  62         cccp_write(dbg, CC_CLOCK, CC_CLOCK);
  63         dbg->clock = 1;
  64         ccdbg_quarter_clock(dbg);
  65 }
  66
  67 /*
  68  * By convention, every macro function is entered with dbg->clock == 1
  69  */
  70
  71 void
  72 ccdbg_write_bit(struct ccdbg *dbg, uint8_t bit)
  73 {
  74         ccdbg_clock_1_0(dbg);
  75         cccp_write(dbg, CC_DATA, bit ? CC_DATA : 0);
  76         ccdbg_clock_0_1(dbg);
  77 }
  78
  79 void
  80 ccdbg_write_byte(struct ccdbg *dbg, uint8_t byte)
  81 {
  82         int     bit;
  83
  84         for (bit = 7; bit >= 0; bit--)
  85                 ccdbg_write_bit(dbg, (byte >> bit) & 1);
  86 }
  87
  88 uint8_t
  89 ccdbg_read_bit(struct ccdbg *dbg)
  90 {
  91         uint8_t data;
  92
  93         ccdbg_clock_1_0(dbg);
  94         data = cccp_read(dbg, CC_DATA);
  95         ccdbg_clock_0_1(dbg);
  96         return data ? 1 : 0;
  97 }
  98
  99 uint8_t
 100 ccdbg_read_byte(struct ccdbg *dbg)
 101 {
 102         int     bit;
 103         uint8_t byte = 0;
 104
 105         for (bit = 7; bit >= 0; bit--)
 106                 byte |= ccdbg_read_bit(dbg) << bit;
 107         return byte;
 108 }
 109
 110 void
 111 ccdbg_cmd_write(struct ccdbg *dbg, uint8_t cmd, uint8_t *data, int len)
 112 {
 113         int     i;
 114         ccdbg_write_byte(dbg, cmd);
 115         for (i = 0; i < len; i++)
 116                 ccdbg_write_byte(dbg, data[i]);
 117 }
 118
 119 uint8_t
 120 ccdbg_cmd_write_read8(struct ccdbg *dbg, uint8_t cmd, uint8_t *data, int len)
 121 {
 122         ccdbg_cmd_write(dbg, cmd, data, len);
 123         return ccdbg_read_byte(dbg);
 124 }
 125
 126 uint16_t
 127 ccdbg_cmd_write_read16(struct ccdbg *dbg, uint8_t cmd, uint8_t *data, int len)
 128 {
 129         uint8_t byte1, byte0;
 130         ccdbg_cmd_write(dbg, cmd, data, len);
 131         byte1 = ccdbg_read_byte(dbg);
 132         byte0 = ccdbg_read_byte(dbg);
 133         return (byte1 << 8) | byte0;
 134 }
 135