[libftdi] / ftdi / ftdi.c

/***************************************************************************
                          ftdi.c  -  description
                             -------------------
    begin                : Fri Apr 4 2003
    copyright            : (C) 2003 by Intra2net AG
    email                : info@intra2net.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Lesser General Public License           *
 *   version 2.1 as published by the Free Software Foundation;             *
 *                                                                         *
 ***************************************************************************/

#include <usb.h>
 
#include "ftdi.h"

int ftdi_init(struct ftdi_context *ftdi) {
    ftdi->usb_dev = NULL;
    ftdi->usb_timeout = 5000;

    ftdi->baudrate = -1;
    ftdi->bitbang_enabled = 0;

    ftdi->error_str = NULL;

    return 0;
}


void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb) {
    ftdi->usb_dev = usb;
}


/* ftdi_usb_open return codes:
   0: all fine
  -1: usb_find_busses() failed
  -2: usb_find_devices() failed
  -3: usb device not found
  -4: unable to open device
  -5: unable to claim device
  -6: reset failed
  -7: set baudrate failed
*/
int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) {
    struct usb_bus *bus;
    struct usb_device *dev;

    usb_init();

    if (usb_find_busses() < 0) {
        ftdi->error_str = "usb_find_busses() failed";
        return -1;
    }

    if (usb_find_devices() < 0) {
        ftdi->error_str = "usb_find_devices() failed";
        return -2;
    }

    for (bus = usb_busses; bus; bus = bus->next) {
        for (dev = bus->devices; dev; dev = dev->next) {
            if (dev->descriptor.idVendor == vendor && dev->descriptor.idProduct == product) {
                ftdi->usb_dev = usb_open(dev);
                if (ftdi->usb_dev) {
                    if (usb_claim_interface(ftdi->usb_dev, 0) != 0) {
                        ftdi->error_str = "unable to claim usb device. You can still use it though...";
                        return -5;
                    }

                    if (ftdi_usb_reset (ftdi) != 0)
                       return -6;

                    if (ftdi_set_baudrate (ftdi, 9600) != 0)
                       return -7;

                    return 0;
                } else {
                    ftdi->error_str = "usb_open() failed";
                    return -4;
                }
            }
        }

    }

    // device not found
    return -3;
}


int ftdi_usb_reset(struct ftdi_context *ftdi) {
    if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 0, 0, NULL, 0, ftdi->usb_timeout) != 0) {
        ftdi->error_str = "FTDI reset failed";
        return -1;
    }

    return 0;
}


/* ftdi_usb_close return codes
    0: all fine
   -1: usb_release failed
   -2: usb_close failed
*/
int ftdi_usb_close(struct ftdi_context *ftdi) {
    int rtn = 0;

    if (usb_release_interface(ftdi->usb_dev, 0) != 0)
        rtn = -1;

    if (usb_close (ftdi->usb_dev) != 0)
        rtn = -2;

    return rtn;
}


/*
    ftdi_set_baudrate return codes:
     0: all fine
    -1: invalid baudrate
    -2: setting baudrate failed
*/
int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) {
    unsigned short ftdi_baudrate;

    if (ftdi->bitbang_enabled) {
        baudrate = baudrate*4;
    }

    switch (baudrate) {
    case 300:
        ftdi_baudrate = 0x2710;
        break;
    case 600:
        ftdi_baudrate = 0x1388;
        break;
    case 1200:
        ftdi_baudrate = 0x09C4;
        break;
    case 2400:
        ftdi_baudrate = 0x04E2;
        break;
    case 4800:
        ftdi_baudrate = 0x0271;
        break;
    case 9600:
        ftdi_baudrate = 0x4138;
        break;
    case 19200:
        ftdi_baudrate = 0x809C;
        break;
    case 38400:
        ftdi_baudrate = 0xC04E;
        break;
    case 57600:
        ftdi_baudrate = 0x0034;
        break;
    case 115200:
        ftdi_baudrate = 0x001A;
        break;
    case 230400:
        ftdi_baudrate = 0x000D;
        break;
    case 460800:
        ftdi_baudrate = 0x4006;
        break;
    case 921600:
        ftdi_baudrate = 0x8003;
        break;
    default:
        ftdi->error_str = "Unknown baudrate. Note: bitbang baudrates are automatically multiplied by 4";
        return -1;
    }

    if (usb_control_msg(ftdi->usb_dev, 0x40, 3, ftdi_baudrate, 0, NULL, 0, ftdi->usb_timeout) != 0) {
        ftdi->error_str = "Setting new baudrate failed";
        return -2;
    }

    ftdi->baudrate = baudrate;
    return 0;
}


int ftdi_write_data(struct ftdi_context *ftdi, char *buf, int size) {
    int ret;
    int offset = 0;
    while (offset < size) {
        int write_size = 64;

        if (offset+write_size > size)
            write_size = size-offset;

        ret=usb_bulk_write(ftdi->usb_dev, 2, buf+offset, write_size, ftdi->usb_timeout);
        if (ret == -1)
            return -1;

        offset += write_size;
    }

    return 0;
}


int ftdi_read_data(struct ftdi_context *ftdi, char *buf, int size) {
    /*
      unsigned char buf[64];
      int read_bytes;

      read_bytes = usb_bulk_read (udev, 0x81, (char *)&buf, 64, USB_TIMEOUT);
    */
    ftdi->error_str = "Not implemented yet";
    return -1;
}


int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask) {
    unsigned short usb_val;

    usb_val = bitmask;	// low byte: bitmask
    usb_val += 1 << 8;	// high byte: enable flag
    if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, 0, NULL, 0, ftdi->usb_timeout) != 0) {
        ftdi->error_str = "Unable to enter bitbang mode. Perhaps not a BM type chip?";
        return -1;
    }

    ftdi->bitbang_enabled = 1;
    return 0;
}


int ftdi_disable_bitbang(struct ftdi_context *ftdi) {
    if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, 0, 0, NULL, 0, ftdi->usb_timeout) != 0) {
        ftdi->error_str = "Unable to leave bitbang mode. Perhaps not a BM type chip?";
        return -1;
    }

    ftdi->bitbang_enabled = 0;
    return 0;
}


int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins) {
    unsigned short usb_val;
    if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0C, 0, 0, (char *)&usb_val, 1, ftdi->usb_timeout) != 1) {
        ftdi->error_str = "Read pins failed";
        return -1;
    }

    *pins = (unsigned char)usb_val;
    return 0;
}


int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency) {
    unsigned short usb_val;

    if (latency < 1) {
       ftdi->error_str = "Latency out of range. Only valid for 1-255";
       return -1;
    }

    if (usb_control_msg(ftdi->usb_dev, 0x40, 0x09, usb_val, 0, NULL, 0, ftdi->usb_timeout) != 0) {
       ftdi->error_str = "Unable to set latency timer";
       return -2;
    }
    return 0;
}


int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency) {
    unsigned short usb_val;
    if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x09, 0, 0, (char *)&usb_val, 1, ftdi->usb_timeout) != 1) {
        ftdi->error_str = "Reading latency timer failed";
        return -1;
    }

    *latency = (unsigned char)usb_val;
    return 0;
}


int ftdi_read_eeprom(struct ftdi_context *ftdi, char *eeprom) {
    int i;

    for (i = 0; i < 64; i++) {
        if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_timeout) != 2) {
           ftdi->error_str = "Reading eeprom failed";
           return -1;
        }
    }

    return 0;
}


int ftdi_write_eeprom(struct ftdi_context *ftdi, char *eeprom) {
    unsigned short usb_val;
    int i;

    for (i = 0; i < 64; i++) {
       usb_val = eeprom[i*2];
       usb_val += eeprom[(i*2)+1] << 8;
       if (usb_control_msg(ftdi->usb_dev, 0x40, 0x91, usb_val, i, NULL, 0, ftdi->usb_timeout) != 0) {
          ftdi->error_str = "Unable to write eeprom";
          return -1;
       }
    }

    return 0;
}


int ftdi_erase_eeprom(struct ftdi_context *ftdi) {
    if (usb_control_msg(ftdi->usb_dev, 0x40, 0x92, 0, 0, NULL, 0, ftdi->usb_timeout) != 0) {
        ftdi->error_str = "Unable to erase eeprom";
        return -1;
    }

    return 0;
}
Commit	Line	Data
a3da1d95 GE	1	/***************************************************************************
	2	ftdi.c - description
	3	-------------------
	4	begin : Fri Apr 4 2003
	5	copyright : (C) 2003 by Intra2net AG
	6	email : info@intra2net.com
	7	***************************************************************************/
	8
	9	/***************************************************************************
	10	* *
	11	* This program is free software; you can redistribute it and/or modify *
	12	* it under the terms of the GNU Lesser General Public License *
	13	* version 2.1 as published by the Free Software Foundation; *
	14	* *
	15	***************************************************************************/
	16
	17	#include <usb.h>
	18
	19	#include "ftdi.h"
	20
	21	int ftdi_init(struct ftdi_context *ftdi) {
	22	ftdi->usb_dev = NULL;
	23	ftdi->usb_timeout = 5000;
	24
	25	ftdi->baudrate = -1;
	26	ftdi->bitbang_enabled = 0;
	27
	28	ftdi->error_str = NULL;
	29
	30	return 0;
	31	}
	32
	33
	34	void ftdi_set_usbdev (struct ftdi_context ftdi, usb_dev_handle usb) {
	35	ftdi->usb_dev = usb;
	36	}
	37
	38
	39	/* ftdi_usb_open return codes:
	40	0: all fine
	41	-1: usb_find_busses() failed
	42	-2: usb_find_devices() failed
	43	-3: usb device not found
	44	-4: unable to open device
	45	-5: unable to claim device
	46	-6: reset failed
	47	-7: set baudrate failed
	48	*/
	49	int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) {
	50	struct usb_bus *bus;
	51	struct usb_device *dev;
	52
	53	usb_init();
	54
	55	if (usb_find_busses() < 0) {
	56	ftdi->error_str = "usb_find_busses() failed";
	57	return -1;
	58	}
	59
	60	if (usb_find_devices() < 0) {
	61	ftdi->error_str = "usb_find_devices() failed";
	62	return -2;
	63	}
	64
65	for (bus = usb_busses; bus; bus = bus->next) {
66	for (dev = bus->devices; dev; dev = dev->next) {
67	if (dev->descriptor.idVendor == vendor && dev->descriptor.idProduct == product) {
68	ftdi->usb_dev = usb_open(dev);
69	if (ftdi->usb_dev) {
70	if (usb_claim_interface(ftdi->usb_dev, 0) != 0) {
71	ftdi->error_str = "unable to claim usb device. You can still use it though...";
72	return -5;
73	}
74
75	if (ftdi_usb_reset (ftdi) != 0)
76	return -6;
77
78	if (ftdi_set_baudrate (ftdi, 9600) != 0)
79	return -7;
80
81	return 0;
82	} else {
83	ftdi->error_str = "usb_open() failed";
84	return -4;
85	}
86	}
87	}
88
89	}
90
91	// device not found
92	return -3;
93	}
94
95
96	int ftdi_usb_reset(struct ftdi_context *ftdi) {
97	if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 0, 0, NULL, 0, ftdi->usb_timeout) != 0) {
98	ftdi->error_str = "FTDI reset failed";
99	return -1;
100	}
101
102	return 0;
103	}
104
105
106	/* ftdi_usb_close return codes
107	0: all fine
108	-1: usb_release failed
109	-2: usb_close failed
110	*/
111	int ftdi_usb_close(struct ftdi_context *ftdi) {
112	int rtn = 0;
113
114	if (usb_release_interface(ftdi->usb_dev, 0) != 0)
115	rtn = -1;
116
117	if (usb_close (ftdi->usb_dev) != 0)
118	rtn = -2;
119
120	return rtn;
121	}
122
123
124	/*
125	ftdi_set_baudrate return codes:
126	0: all fine
127	-1: invalid baudrate
128	-2: setting baudrate failed
129	*/
130	int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) {
131	unsigned short ftdi_baudrate;
132
133	if (ftdi->bitbang_enabled) {
134	baudrate = baudrate*4;
135	}
136
137	switch (baudrate) {
138	case 300:
139	ftdi_baudrate = 0x2710;
140	break;
141	case 600:
142	ftdi_baudrate = 0x1388;
143	break;
144	case 1200:
145	ftdi_baudrate = 0x09C4;
146	break;
147	case 2400:
148	ftdi_baudrate = 0x04E2;
149	break;
150	case 4800:
151	ftdi_baudrate = 0x0271;
152	break;
153	case 9600:
154	ftdi_baudrate = 0x4138;
155	break;
156	case 19200:
157	ftdi_baudrate = 0x809C;
158	break;
159	case 38400:
160	ftdi_baudrate = 0xC04E;
161	break;
162	case 57600:
163	ftdi_baudrate = 0x0034;
164	break;
165	case 115200:
166	ftdi_baudrate = 0x001A;
167	break;
168	case 230400:
169	ftdi_baudrate = 0x000D;
170	break;
171	case 460800:
172	ftdi_baudrate = 0x4006;
173	break;
174	case 921600:
175	ftdi_baudrate = 0x8003;
176	break;
177	default:
178	ftdi->error_str = "Unknown baudrate. Note: bitbang baudrates are automatically multiplied by 4";
179	return -1;
180	}
181
182	if (usb_control_msg(ftdi->usb_dev, 0x40, 3, ftdi_baudrate, 0, NULL, 0, ftdi->usb_timeout) != 0) {
183	ftdi->error_str = "Setting new baudrate failed";
184	return -2;
185	}
186
187	ftdi->baudrate = baudrate;
188	return 0;
189	}
190
191
192	int ftdi_write_data(struct ftdi_context ftdi, char buf, int size) {
193	int ret;
194	int offset = 0;
195	while (offset < size) {
196	int write_size = 64;
197
198	if (offset+write_size > size)
199	write_size = size-offset;
200
201	ret=usb_bulk_write(ftdi->usb_dev, 2, buf+offset, write_size, ftdi->usb_timeout);
202	if (ret == -1)
203	return -1;
204
205	offset += write_size;
206	}
207
208	return 0;
209	}
210
211
212	int ftdi_read_data(struct ftdi_context ftdi, char buf, int size) {
213	/*
214	unsigned char buf[64];
215	int read_bytes;
216
217	read_bytes = usb_bulk_read (udev, 0x81, (char *)&buf, 64, USB_TIMEOUT);
218	*/
219	ftdi->error_str = "Not implemented yet";
220	return -1;
221	}
222
223
224	int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask) {
225	unsigned short usb_val;
226
227	usb_val = bitmask; // low byte: bitmask
228	usb_val += 1 << 8; // high byte: enable flag
229	if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, 0, NULL, 0, ftdi->usb_timeout) != 0) {
230	ftdi->error_str = "Unable to enter bitbang mode. Perhaps not a BM type chip?";
231	return -1;
232	}
233
234	ftdi->bitbang_enabled = 1;
235	return 0;
236	}
237
238
239	int ftdi_disable_bitbang(struct ftdi_context *ftdi) {
240	if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, 0, 0, NULL, 0, ftdi->usb_timeout) != 0) {
241	ftdi->error_str = "Unable to leave bitbang mode. Perhaps not a BM type chip?";
242	return -1;
243	}
244
245	ftdi->bitbang_enabled = 0;
246	return 0;
247	}
248
249
250	int ftdi_read_pins(struct ftdi_context ftdi, unsigned char pins) {
251	unsigned short usb_val;
252	if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0C, 0, 0, (char *)&usb_val, 1, ftdi->usb_timeout) != 1) {
253	ftdi->error_str = "Read pins failed";
254	return -1;
255	}
256
257	*pins = (unsigned char)usb_val;
258	return 0;
259	}
260
261
262	int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency) {
263	unsigned short usb_val;
264
265	if (latency < 1) {
266	ftdi->error_str = "Latency out of range. Only valid for 1-255";
267	return -1;
268	}
269
270	if (usb_control_msg(ftdi->usb_dev, 0x40, 0x09, usb_val, 0, NULL, 0, ftdi->usb_timeout) != 0) {
271	ftdi->error_str = "Unable to set latency timer";
272	return -2;
273	}
274	return 0;
275	}
276
277
278	int ftdi_get_latency_timer(struct ftdi_context ftdi, unsigned char latency) {
279	unsigned short usb_val;
280	if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x09, 0, 0, (char *)&usb_val, 1, ftdi->usb_timeout) != 1) {
281	ftdi->error_str = "Reading latency timer failed";
282	return -1;
283	}
284
285	*latency = (unsigned char)usb_val;
286	return 0;
287	}
288
289
290	int ftdi_read_eeprom(struct ftdi_context ftdi, char eeprom) {
291	int i;
292
293	for (i = 0; i < 64; i++) {
294	if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_timeout) != 2) {
295	ftdi->error_str = "Reading eeprom failed";
296	return -1;
297	}
298	}
299
300	return 0;
301	}
302
303
304	int ftdi_write_eeprom(struct ftdi_context ftdi, char eeprom) {
305	unsigned short usb_val;
306	int i;
307
308	for (i = 0; i < 64; i++) {
309	usb_val = eeprom[i*2];
310	usb_val += eeprom[(i*2)+1] << 8;
311	if (usb_control_msg(ftdi->usb_dev, 0x40, 0x91, usb_val, i, NULL, 0, ftdi->usb_timeout) != 0) {
312	ftdi->error_str = "Unable to write eeprom";
313	return -1;
314	}
315	}
316
317	return 0;
318	}
319
320
321	int ftdi_erase_eeprom(struct ftdi_context *ftdi) {
322	if (usb_control_msg(ftdi->usb_dev, 0x40, 0x92, 0, 0, NULL, 0, ftdi->usb_timeout) != 0) {
323	ftdi->error_str = "Unable to erase eeprom";
324	return -1;
325	}
326
327	return 0;
328	}