Flashrom

Flashrom Svn Source Tree

Root/trunk/ft2232_spi.c

1/*␊
2 * This file is part of the flashrom project.␊
3 *␊
4 * Copyright (C) 2009 Paul Fox <pgf@laptop.org>␊
5 * Copyright (C) 2009, 2010 Carl-Daniel Hailfinger␊
6 *␊
7 * This program is free software; you can redistribute it and/or modify␊
8 * it under the terms of the GNU General Public License as published by␊
9 * the Free Software Foundation; version 2 of the License.␊
10 *␊
11 * This program is distributed in the hope that it will be useful,␊
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of␊
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the␊
14 * GNU General Public License for more details.␊
15 *␊
16 * You should have received a copy of the GNU General Public License␊
17 * along with this program; if not, write to the Free Software␊
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA␊
19 */␊
20␊
21#if CONFIG_FT2232_SPI == 1␊
22␊
23#include <stdio.h>␊
24#include <string.h>␊
25#include <stdlib.h>␊
26#include <ctype.h>␊
27#include "flash.h"␊
28#include "programmer.h"␊
29#include "spi.h"␊
30#include <ftdi.h>␊
31␊
32/* Please keep sorted by vendor ID, then device ID. */␊
33␊
34#define FTDI_VID␉␉0x0403␊
35#define FTDI_FT2232H_PID␉0x6010␊
36#define FTDI_FT4232H_PID␉0x6011␊
37#define TIAO_TUMPA_PID␉␉0x8a98␊
38#define AMONTEC_JTAGKEY_PID␉0xCFF8␊
39␊
40#define GOEPEL_VID␉␉0x096C␊
41#define GOEPEL_PICOTAP_PID␉0x1449␊
42␊
43#define FIC_VID␉␉␉0x1457␊
44#define OPENMOKO_DBGBOARD_PID␉0x5118␊
45␊
46#define OLIMEX_VID␉␉0x15BA␊
47#define OLIMEX_ARM_OCD_PID␉0x0003␊
48#define OLIMEX_ARM_TINY_PID␉0x0004␊
49#define OLIMEX_ARM_OCD_H_PID␉0x002B␊
50#define OLIMEX_ARM_TINY_H_PID␉0x002A␊
51␊
52const struct usbdev_status devs_ft2232spi[] = {␊
53␉{FTDI_VID, FTDI_FT2232H_PID, OK, "FTDI", "FT2232H"},␊
54␉{FTDI_VID, FTDI_FT4232H_PID, OK, "FTDI", "FT4232H"},␊
55␉{FTDI_VID, TIAO_TUMPA_PID, OK, "TIAO", "USB Multi-Protocol Adapter"},␊
56␉{FTDI_VID, AMONTEC_JTAGKEY_PID, OK, "Amontec", "JTAGkey"},␊
57␉{GOEPEL_VID, GOEPEL_PICOTAP_PID, OK, "GOEPEL", "PicoTAP"},␊
58␉{FIC_VID, OPENMOKO_DBGBOARD_PID, OK, "FIC",␊
59␉␉"OpenMoko Neo1973 Debug board (V2+)"},␊
60␉{OLIMEX_VID, OLIMEX_ARM_OCD_PID, NT, "Olimex", "ARM-USB-OCD"},␊
61␉{OLIMEX_VID, OLIMEX_ARM_TINY_PID, OK, "Olimex", "ARM-USB-TINY"},␊
62␉{OLIMEX_VID, OLIMEX_ARM_OCD_H_PID, NT, "Olimex", "ARM-USB-OCD-H"},␊
63␉{OLIMEX_VID, OLIMEX_ARM_TINY_H_PID, NT, "Olimex", "ARM-USB-TINY-H"},␊
64␉{},␊
65};␊
66␊
67/*␊
68 * The 'H' chips can run internally at either 12MHz or 60MHz.␊
69 * The non-H chips can only run at 12MHz.␊
70 */␊
71static uint8_t clock_5x = 1;␊
72␊
73/*␊
74 * In either case, the divisor is a simple integer clock divider.␊
75 * If clock_5x is set, this divisor divides 30MHz, else it divides 6MHz.␊
76 */␊
77#define DIVIDE_BY 3 /* e.g. '3' will give either 10MHz or 2MHz SPI clock. */␊
78␊
79#define BITMODE_BITBANG_NORMAL␉1␊
80#define BITMODE_BITBANG_SPI␉2␊
81␊
82/* Set data bits low-byte command:␊
83 * value: 0x08 CS=high, DI=low, DO=low, SK=low␊
84 * dir: 0x0b CS=output, DI=input, DO=output, SK=output␊
85 *␊
86 * JTAGkey(2) needs to enable its output via Bit4 / GPIOL0␊
87 * value: 0x18 OE=high, CS=high, DI=low, DO=low, SK=low␊
88 * dir: 0x1b OE=output, CS=output, DI=input, DO=output, SK=output␊
89 */␊
90static uint8_t cs_bits = 0x08;␊
91static uint8_t pindir = 0x0b;␊
92static struct ftdi_context ftdic_context;␊
93␊
94static const char *get_ft2232_devicename(int ft2232_vid, int ft2232_type)␊
95{␊
96␉int i;␊
97␉for (i = 0; devs_ft2232spi[i].vendor_name != NULL; i++) {␊
98␉␉if ((devs_ft2232spi[i].device_id == ft2232_type)␊
99␉␉␉&& (devs_ft2232spi[i].vendor_id == ft2232_vid))␊
100␉␉␉␉return devs_ft2232spi[i].device_name;␊
101␉}␊
102␉return "unknown device";␊
103}␊
104␊
105static const char *get_ft2232_vendorname(int ft2232_vid, int ft2232_type)␊
106{␊
107␉int i;␊
108␉for (i = 0; devs_ft2232spi[i].vendor_name != NULL; i++) {␊
109␉␉if ((devs_ft2232spi[i].device_id == ft2232_type)␊
110␉␉␉&& (devs_ft2232spi[i].vendor_id == ft2232_vid))␊
111␉␉␉␉return devs_ft2232spi[i].vendor_name;␊
112␉}␊
113␉return "unknown vendor";␊
114}␊
115␊
116static int send_buf(struct ftdi_context *ftdic, const unsigned char *buf,␊
117␉␉ int size)␊
118{␊
119␉int r;␊
120␉r = ftdi_write_data(ftdic, (unsigned char *) buf, size);␊
121␉if (r < 0) {␊
122␉␉msg_perr("ftdi_write_data: %d, %s\n", r,␊
123␉␉␉␉ftdi_get_error_string(ftdic));␊
124␉␉return 1;␊
125␉}␊
126␉return 0;␊
127}␊
128␊
129static int get_buf(struct ftdi_context *ftdic, const unsigned char *buf,␊
130␉␉ int size)␊
131{␊
132␉int r;␊
133␊
134␉while (size > 0) {␊
135␉␉r = ftdi_read_data(ftdic, (unsigned char *) buf, size);␊
136␉␉if (r < 0) {␊
137␉␉␉msg_perr("ftdi_read_data: %d, %s\n", r,␊
138␉␉␉␉␉ftdi_get_error_string(ftdic));␊
139␉␉␉return 1;␊
140␉␉}␊
141␉␉buf += r;␊
142␉␉size -= r;␊
143␉}␊
144␉return 0;␊
145}␊
146␊
147static int ft2232_spi_send_command(struct flashctx *flash,␊
148␉␉␉␉ unsigned int writecnt, unsigned int readcnt,␊
149␉␉␉␉ const unsigned char *writearr,␊
150␉␉␉␉ unsigned char *readarr);␊
151␊
152static const struct spi_programmer spi_programmer_ft2232 = {␊
153␉.type␉␉= SPI_CONTROLLER_FT2232,␊
154␉.max_data_read␉= 64 * 1024,␊
155␉.max_data_write␉= 256,␊
156␉.command␉= ft2232_spi_send_command,␊
157␉.multicommand␉= default_spi_send_multicommand,␊
158␉.read␉␉= default_spi_read,␊
159␉.write_256␉= default_spi_write_256,␊
160};␊
161␊
162/* Returns 0 upon success, a negative number upon errors. */␊
163int ft2232_spi_init(void)␊
164{␊
165␉int f, ret = 0;␊
166␉struct ftdi_context *ftdic = &ftdic_context;␊
167␉unsigned char buf[512];␊
168␉int ft2232_vid = FTDI_VID;␊
169␉int ft2232_type = FTDI_FT4232H_PID;␊
170␉enum ftdi_interface ft2232_interface = INTERFACE_B;␊
171␉char *arg;␊
172␉double mpsse_clk;␊
173␊
174␉arg = extract_programmer_param("type");␊
175␉if (arg) {␊
176␉␉if (!strcasecmp(arg, "2232H"))␊
177␉␉␉ft2232_type = FTDI_FT2232H_PID;␊
178␉␉else if (!strcasecmp(arg, "4232H"))␊
179␉␉␉ft2232_type = FTDI_FT4232H_PID;␊
180␉␉else if (!strcasecmp(arg, "jtagkey")) {␊
181␉␉␉ft2232_type = AMONTEC_JTAGKEY_PID;␊
182␉␉␉ft2232_interface = INTERFACE_A;␊
183␉␉␉cs_bits = 0x18;␊
184␉␉␉pindir = 0x1b;␊
185␉␉} else if (!strcasecmp(arg, "picotap")) {␊
186␉␉␉ft2232_vid = GOEPEL_VID;␊
187␉␉␉ft2232_type = GOEPEL_PICOTAP_PID;␊
188␉␉␉ft2232_interface = INTERFACE_A;␊
189␉␉} else if (!strcasecmp(arg, "tumpa")) {␊
190␉␉␉/* Interface A is SPI1, B is SPI2. */␊
191␉␉␉ft2232_type = TIAO_TUMPA_PID;␊
192␉␉␉ft2232_interface = INTERFACE_A;␊
193␉␉} else if (!strcasecmp(arg, "busblaster")) {␊
194␉␉␉/* In its default configuration it is a jtagkey clone */␊
195␉␉␉ft2232_type = FTDI_FT2232H_PID;␊
196␉␉␉ft2232_interface = INTERFACE_A;␊
197␉␉␉cs_bits = 0x18;␊
198␉␉␉pindir = 0x1b;␊
199␉␉} else if (!strcasecmp(arg, "openmoko")) {␊
200␉␉␉ft2232_vid = FIC_VID;␊
201␉␉␉ft2232_type = OPENMOKO_DBGBOARD_PID;␊
202␉␉␉ft2232_interface = INTERFACE_A;␊
203␉␉} else if (!strcasecmp(arg, "arm-usb-ocd")) {␊
204␉␉␉ft2232_vid = OLIMEX_VID;␊
205␉␉␉ft2232_type = OLIMEX_ARM_OCD_PID;␊
206␉␉␉ft2232_interface = INTERFACE_A;␊
207␉␉␉cs_bits = 0x08;␊
208␉␉␉pindir = 0x1b;␊
209␉␉} else if (!strcasecmp(arg, "arm-usb-tiny")) {␊
210␉␉␉ft2232_vid = OLIMEX_VID;␊
211␉␉␉ft2232_type = OLIMEX_ARM_TINY_PID;␊
212␉␉␉ft2232_interface = INTERFACE_A;␊
213␉␉} else if (!strcasecmp(arg, "arm-usb-ocd-h")) {␊
214␉␉␉ft2232_vid = OLIMEX_VID;␊
215␉␉␉ft2232_type = OLIMEX_ARM_OCD_H_PID;␊
216␉␉␉ft2232_interface = INTERFACE_A;␊
217␉␉␉cs_bits = 0x08;␊
218␉␉␉pindir = 0x1b;␊
219␉␉} else if (!strcasecmp(arg, "arm-usb-tiny-h")) {␊
220␉␉␉ft2232_vid = OLIMEX_VID;␊
221␉␉␉ft2232_type = OLIMEX_ARM_TINY_H_PID;␊
222␉␉␉ft2232_interface = INTERFACE_A;␊
223␉␉} else {␊
224␉␉␉msg_perr("Error: Invalid device type specified.\n");␊
225␉␉␉free(arg);␊
226␉␉␉return -1;␊
227␉␉}␊
228␉}␊
229␉free(arg);␊
230␉arg = extract_programmer_param("port");␊
231␉if (arg) {␊
232␉␉switch (toupper((unsigned char)*arg)) {␊
233␉␉case 'A':␊
234␉␉␉ft2232_interface = INTERFACE_A;␊
235␉␉␉break;␊
236␉␉case 'B':␊
237␉␉␉ft2232_interface = INTERFACE_B;␊
238␉␉␉break;␊
239␉␉default:␊
240␉␉␉msg_perr("Error: Invalid port/interface specified.\n");␊
241␉␉␉free(arg);␊
242␉␉␉return -2;␊
243␉␉}␊
244␉}␊
245␉free(arg);␊
246␉msg_pdbg("Using device type %s %s ",␊
247␉␉ get_ft2232_vendorname(ft2232_vid, ft2232_type),␊
248␉␉ get_ft2232_devicename(ft2232_vid, ft2232_type));␊
249␉msg_pdbg("interface %s\n",␊
250␉␉ (ft2232_interface == INTERFACE_A) ? "A" : "B");␊
251␊
252␉if (ftdi_init(ftdic) < 0) {␊
253␉␉msg_perr("ftdi_init failed\n");␊
254␉␉return -3;␊
255␉}␊
256␊
257␉f = ftdi_usb_open(ftdic, ft2232_vid, ft2232_type);␊
258␊
259␉if (f < 0 && f != -5) {␊
260␉␉msg_perr("Unable to open FTDI device: %d (%s)\n", f,␊
261␉␉␉␉ftdi_get_error_string(ftdic));␊
262␉␉return -4;␊
263␉}␊
264␊
265␉if (ftdic->type != TYPE_2232H && ftdic->type != TYPE_4232H) {␊
266␉␉msg_pdbg("FTDI chip type %d is not high-speed\n",␊
267␉␉␉ftdic->type);␊
268␉␉clock_5x = 0;␊
269␉}␊
270␊
271␉if (ftdi_set_interface(ftdic, ft2232_interface) < 0) {␊
272␉␉msg_perr("Unable to select interface: %s\n",␊
273␉␉␉␉ftdic->error_str);␊
274␉}␊
275␊
276␉if (ftdi_usb_reset(ftdic) < 0) {␊
277␉␉msg_perr("Unable to reset FTDI device\n");␊
278␉}␊
279␊
280␉if (ftdi_set_latency_timer(ftdic, 2) < 0) {␊
281␉␉msg_perr("Unable to set latency timer\n");␊
282␉}␊
283␊
284␉if (ftdi_write_data_set_chunksize(ftdic, 256)) {␊
285␉␉msg_perr("Unable to set chunk size\n");␊
286␉}␊
287␊
288␉if (ftdi_set_bitmode(ftdic, 0x00, BITMODE_BITBANG_SPI) < 0) {␊
289␉␉msg_perr("Unable to set bitmode to SPI\n");␊
290␉}␊
291␊
292␉if (clock_5x) {␊
293␉␉msg_pdbg("Disable divide-by-5 front stage\n");␊
294␉␉buf[0] = 0x8a;␉␉/* Disable divide-by-5. */␊
295␉␉if (send_buf(ftdic, buf, 1)) {␊
296␉␉␉ret = -5;␊
297␉␉␉goto ftdi_err;␊
298␉␉}␊
299␉␉mpsse_clk = 60.0;␊
300␉} else {␊
301␉␉mpsse_clk = 12.0;␊
302␉}␊
303␊
304␉msg_pdbg("Set clock divisor\n");␊
305␉buf[0] = 0x86;␉␉/* command "set divisor" */␊
306␉/* valueL/valueH are (desired_divisor - 1) */␊
307␉buf[1] = (DIVIDE_BY - 1) & 0xff;␊
308␉buf[2] = ((DIVIDE_BY - 1) >> 8) & 0xff;␊
309␉if (send_buf(ftdic, buf, 3)) {␊
310␉␉ret = -6;␊
311␉␉goto ftdi_err;␊
312␉}␊
313␊
314␉msg_pdbg("MPSSE clock: %f MHz divisor: %d "␊
315␉␉ "SPI clock: %f MHz\n", mpsse_clk, DIVIDE_BY,␊
316␉␉ (double)(mpsse_clk / (((DIVIDE_BY - 1) + 1) * 2)));␊
317␊
318␉/* Disconnect TDI/DO to TDO/DI for loopback. */␊
319␉msg_pdbg("No loopback of TDI/DO TDO/DI\n");␊
320␉buf[0] = 0x85;␊
321␉if (send_buf(ftdic, buf, 1)) {␊
322␉␉ret = -7;␊
323␉␉goto ftdi_err;␊
324␉}␊
325␊
326␉msg_pdbg("Set data bits\n");␊
327␉buf[0] = SET_BITS_LOW;␊
328␉buf[1] = cs_bits;␊
329␉buf[2] = pindir;␊
330␉if (send_buf(ftdic, buf, 3)) {␊
331␉␉ret = -8;␊
332␉␉goto ftdi_err;␊
333␉}␊
334␊
335␉// msg_pdbg("\nft2232 chosen\n");␊
336␊
337␉register_spi_programmer(&spi_programmer_ft2232);␊
338␊
339␉return 0;␊
340␊
341ftdi_err:␊
342␉if ((f = ftdi_usb_close(ftdic)) < 0) {␊
343␉␉msg_perr("Unable to close FTDI device: %d (%s)\n", f,␊
344␉␉ ftdi_get_error_string(ftdic));␊
345␉}␊
346␊
347␉return ret;␊
348}␊
349␊
350/* Returns 0 upon success, a negative number upon errors. */␊
351static int ft2232_spi_send_command(struct flashctx *flash,␊
352␉␉␉␉ unsigned int writecnt, unsigned int readcnt,␊
353␉␉␉␉ const unsigned char *writearr,␊
354␉␉␉␉ unsigned char *readarr)␊
355{␊
356␉struct ftdi_context *ftdic = &ftdic_context;␊
357␉static unsigned char *buf = NULL;␊
358␉/* failed is special. We use bitwise ops, but it is essentially bool. */␊
359␉int i = 0, ret = 0, failed = 0;␊
360␉int bufsize;␊
361␉static int oldbufsize = 0;␊
362␊
363␉if (writecnt > 65536 || readcnt > 65536)␊
364␉␉return SPI_INVALID_LENGTH;␊
365␊
366␉/* buf is not used for the response from the chip. */␊
367␉bufsize = max(writecnt + 9, 260 + 9);␊
368␉/* Never shrink. realloc() calls are expensive. */␊
369␉if (bufsize > oldbufsize) {␊
370␉␉buf = realloc(buf, bufsize);␊
371␉␉if (!buf) {␊
372␉␉␉msg_perr("Out of memory!\n");␊
373␉␉␉/* TODO: What to do with buf? */␊
374␉␉␉return SPI_GENERIC_ERROR;␊
375␉␉}␊
376␉␉oldbufsize = bufsize;␊
377␉}␊
378␊
379␉/*␊
380␉ * Minimize USB transfers by packing as many commands as possible␊
381␉ * together. If we're not expecting to read, we can assert CS#, write,␊
382␉ * and deassert CS# all in one shot. If reading, we do three separate␊
383␉ * operations.␊
384␉ */␊
385␉msg_pspew("Assert CS#\n");␊
386␉buf[i++] = SET_BITS_LOW;␊
387␉buf[i++] = 0 & ~cs_bits; /* assertive */␊
388␉buf[i++] = pindir;␊
389␊
390␉if (writecnt) {␊
391␉␉buf[i++] = 0x11;␊
392␉␉buf[i++] = (writecnt - 1) & 0xff;␊
393␉␉buf[i++] = ((writecnt - 1) >> 8) & 0xff;␊
394␉␉memcpy(buf + i, writearr, writecnt);␊
395␉␉i += writecnt;␊
396␉}␊
397␊
398␉/*␊
399␉ * Optionally terminate this batch of commands with a␊
400␉ * read command, then do the fetch of the results.␊
401␉ */␊
402␉if (readcnt) {␊
403␉␉buf[i++] = 0x20;␊
404␉␉buf[i++] = (readcnt - 1) & 0xff;␊
405␉␉buf[i++] = ((readcnt - 1) >> 8) & 0xff;␊
406␉␉ret = send_buf(ftdic, buf, i);␊
407␉␉failed = ret;␊
408␉␉/* We can't abort here, we still have to deassert CS#. */␊
409␉␉if (ret)␊
410␉␉␉msg_perr("send_buf failed before read: %i\n", ret);␊
411␉␉i = 0;␊
412␉␉if (ret == 0) {␊
413␉␉␉/*␊
414␉␉␉ * FIXME: This is unreliable. There's no guarantee that␊
415␉␉␉ * we read the response directly after sending the read␊
416␉␉␉ * command. We may be scheduled out etc.␊
417␉␉␉ */␊
418␉␉␉ret = get_buf(ftdic, readarr, readcnt);␊
419␉␉␉failed |= ret;␊
420␉␉␉/* We can't abort here either. */␊
421␉␉␉if (ret)␊
422␉␉␉␉msg_perr("get_buf failed: %i\n", ret);␊
423␉␉}␊
424␉}␊
425␊
426␉msg_pspew("De-assert CS#\n");␊
427␉buf[i++] = SET_BITS_LOW;␊
428␉buf[i++] = cs_bits;␊
429␉buf[i++] = pindir;␊
430␉ret = send_buf(ftdic, buf, i);␊
431␉failed |= ret;␊
432␉if (ret)␊
433␉␉msg_perr("send_buf failed at end: %i\n", ret);␊
434␊
435␉return failed ? -1 : 0;␊
436}␊
437␊
438void print_supported_usbdevs(const struct usbdev_status *devs)␊
439{␊
440␉int i;␊
441␊
442␉msg_pinfo("USB devices:\n");␊
443␉for (i = 0; devs[i].vendor_name != NULL; i++) {␊
444␉␉msg_pinfo("%s %s [%04x:%04x]%s\n", devs[i].vendor_name,␊
445␉␉␉ devs[i].device_name, devs[i].vendor_id,␊
446␉␉␉ devs[i].device_id,␊
447␉␉␉ (devs[i].status == NT) ? " (untested)" : "");␊
448␉}␊
449}␊
450␊
451#endif␊
452

Archive Download this file

Revision: HEAD