[mirror_ubuntu-bionic-kernel.git] / arch / mips / cavium-octeon / executive / octeon-model.c

/***********************license start***************
 * Author: Cavium Networks
 *
 * Contact: support@caviumnetworks.com
 * This file is part of the OCTEON SDK
 *
 * Copyright (c) 2003-2008 Cavium Networks
 *
 * This file is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, Version 2, as
 * published by the Free Software Foundation.
 *
 * This file is distributed in the hope that it will be useful, but
 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
 * NONINFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this file; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 * or visit http://www.gnu.org/licenses/.
 *
 * This file may also be available under a different license from Cavium.
 * Contact Cavium Networks for more information
 ***********************license end**************************************/

/*
 * File defining functions for working with different Octeon
 * models.
 */
#include <asm/octeon/octeon.h>

/**
 * Given the chip processor ID from COP0, this function returns a
 * string representing the chip model number. The string is of the
 * form CNXXXXpX.X-FREQ-SUFFIX.
 * - XXXX = The chip model number
 * - X.X = Chip pass number
 * - FREQ = Current frequency in Mhz
 * - SUFFIX = NSP, EXP, SCP, SSP, or CP
 *
 * @chip_id: Chip ID
 *
 * Returns Model string
 */
const char *octeon_model_get_string(uint32_t chip_id)
{
	static char buffer[32];
	return octeon_model_get_string_buffer(chip_id, buffer);
}

/*
 * Version of octeon_model_get_string() that takes buffer as argument,
 * as running early in u-boot static/global variables don't work when
 * running from flash.
 */
const char *octeon_model_get_string_buffer(uint32_t chip_id, char *buffer)
{
	const char *family;
	const char *core_model;
	char pass[4];
	int clock_mhz;
	const char *suffix;
	union cvmx_l2d_fus3 fus3;
	int num_cores;
	union cvmx_mio_fus_dat2 fus_dat2;
	union cvmx_mio_fus_dat3 fus_dat3;
	char fuse_model[10];
	uint32_t fuse_data = 0;

	fus3.u64 = cvmx_read_csr(CVMX_L2D_FUS3);
	fus_dat2.u64 = cvmx_read_csr(CVMX_MIO_FUS_DAT2);
	fus_dat3.u64 = cvmx_read_csr(CVMX_MIO_FUS_DAT3);

	num_cores = cvmx_octeon_num_cores();

	/* Make sure the non existent devices look disabled */
	switch ((chip_id >> 8) & 0xff) {
	case 6:		/* CN50XX */
	case 2:		/* CN30XX */
		fus_dat3.s.nodfa_dte = 1;
		fus_dat3.s.nozip = 1;
		break;
	case 4:		/* CN57XX or CN56XX */
		fus_dat3.s.nodfa_dte = 1;
		break;
	default:
		break;
	}

	/* Make a guess at the suffix */
	/* NSP = everything */
	/* EXP = No crypto */
	/* SCP = No DFA, No zip */
	/* CP = No DFA, No crypto, No zip */
	if (fus_dat3.s.nodfa_dte) {
		if (fus_dat2.s.nocrypto)
			suffix = "CP";
		else
			suffix = "SCP";
	} else if (fus_dat2.s.nocrypto)
		suffix = "EXP";
	else
		suffix = "NSP";

	/*
	 * Assume pass number is encoded using <5:3><2:0>. Exceptions
	 * will be fixed later.
	 */
	sprintf(pass, "%u.%u", ((chip_id >> 3) & 7) + 1, chip_id & 7);

	/*
	 * Use the number of cores to determine the last 2 digits of
	 * the model number. There are some exceptions that are fixed
	 * later.
	 */
	switch (num_cores) {
	case 16:
		core_model = "60";
		break;
	case 15:
		core_model = "58";
		break;
	case 14:
		core_model = "55";
		break;
	case 13:
		core_model = "52";
		break;
	case 12:
		core_model = "50";
		break;
	case 11:
		core_model = "48";
		break;
	case 10:
		core_model = "45";
		break;
	case 9:
		core_model = "42";
		break;
	case 8:
		core_model = "40";
		break;
	case 7:
		core_model = "38";
		break;
	case 6:
		core_model = "34";
		break;
	case 5:
		core_model = "32";
		break;
	case 4:
		core_model = "30";
		break;
	case 3:
		core_model = "25";
		break;
	case 2:
		core_model = "20";
		break;
	case 1:
		core_model = "10";
		break;
	default:
		core_model = "XX";
		break;
	}

	/* Now figure out the family, the first two digits */
	switch ((chip_id >> 8) & 0xff) {
	case 0:		/* CN38XX, CN37XX or CN36XX */
		if (fus3.cn38xx.crip_512k) {
			/*
			 * For some unknown reason, the 16 core one is
			 * called 37 instead of 36.
			 */
			if (num_cores >= 16)
				family = "37";
			else
				family = "36";
		} else
			family = "38";
		/*
		 * This series of chips didn't follow the standard
		 * pass numbering.
		 */
		switch (chip_id & 0xf) {
		case 0:
			strcpy(pass, "1.X");
			break;
		case 1:
			strcpy(pass, "2.X");
			break;
		case 3:
			strcpy(pass, "3.X");
			break;
		default:
			strcpy(pass, "X.X");
			break;
		}
		break;
	case 1:		/* CN31XX or CN3020 */
		if ((chip_id & 0x10) || fus3.cn31xx.crip_128k)
			family = "30";
		else
			family = "31";
		/*
		 * This series of chips didn't follow the standard
		 * pass numbering.
		 */
		switch (chip_id & 0xf) {
		case 0:
			strcpy(pass, "1.0");
			break;
		case 2:
			strcpy(pass, "1.1");
			break;
		default:
			strcpy(pass, "X.X");
			break;
		}
		break;
	case 2:		/* CN3010 or CN3005 */
		family = "30";
		/* A chip with half cache is an 05 */
		if (fus3.cn30xx.crip_64k)
			core_model = "05";
		/*
		 * This series of chips didn't follow the standard
		 * pass numbering.
		 */
		switch (chip_id & 0xf) {
		case 0:
			strcpy(pass, "1.0");
			break;
		case 2:
			strcpy(pass, "1.1");
			break;
		default:
			strcpy(pass, "X.X");
			break;
		}
		break;
	case 3:		/* CN58XX */
		family = "58";
		/* Special case. 4 core, no crypto */
		if ((num_cores == 4) && fus_dat2.cn38xx.nocrypto)
			core_model = "29";

		/* Pass 1 uses different encodings for pass numbers */
		if ((chip_id & 0xFF) < 0x8) {
			switch (chip_id & 0x3) {
			case 0:
				strcpy(pass, "1.0");
				break;
			case 1:
				strcpy(pass, "1.1");
				break;
			case 3:
				strcpy(pass, "1.2");
				break;
			default:
				strcpy(pass, "1.X");
				break;
			}
		}
		break;
	case 4:		/* CN57XX, CN56XX, CN55XX, CN54XX */
		if (fus_dat2.cn56xx.raid_en) {
			if (fus3.cn56xx.crip_1024k)
				family = "55";
			else
				family = "57";
			if (fus_dat2.cn56xx.nocrypto)
				suffix = "SP";
			else
				suffix = "SSP";
		} else {
			if (fus_dat2.cn56xx.nocrypto)
				suffix = "CP";
			else {
				suffix = "NSP";
				if (fus_dat3.s.nozip)
					suffix = "SCP";
			}
			if (fus3.cn56xx.crip_1024k)
				family = "54";
			else
				family = "56";
		}
		break;
	case 6:		/* CN50XX */
		family = "50";
		break;
	case 7:		/* CN52XX */
		if (fus3.cn52xx.crip_256k)
			family = "51";
		else
			family = "52";
		break;
	default:
		family = "XX";
		core_model = "XX";
		strcpy(pass, "X.X");
		suffix = "XXX";
		break;
	}

	clock_mhz = octeon_get_clock_rate() / 1000000;

	if (family[0] != '3') {
		/* Check for model in fuses, overrides normal decode */
		/* This is _not_ valid for Octeon CN3XXX models */
		fuse_data |= cvmx_fuse_read_byte(51);
		fuse_data = fuse_data << 8;
		fuse_data |= cvmx_fuse_read_byte(50);
		fuse_data = fuse_data << 8;
		fuse_data |= cvmx_fuse_read_byte(49);
		fuse_data = fuse_data << 8;
		fuse_data |= cvmx_fuse_read_byte(48);
		if (fuse_data & 0x7ffff) {
			int model = fuse_data & 0x3fff;
			int suffix = (fuse_data >> 14) & 0x1f;
			if (suffix && model) {
				/*
				 * Have both number and suffix in
				 * fuses, so both
				 */
				sprintf(fuse_model, "%d%c",
					model, 'A' + suffix - 1);
				core_model = "";
				family = fuse_model;
			} else if (suffix && !model) {
				/*
				 * Only have suffix, so add suffix to
				 * 'normal' model number.
				 */
				sprintf(fuse_model, "%s%c", core_model,
					'A' + suffix - 1);
				core_model = fuse_model;
			} else {
				/*
				 * Don't have suffix, so just use
				 * model from fuses.
				 */
				sprintf(fuse_model, "%d", model);
				core_model = "";
				family = fuse_model;
			}
		}
	}
	sprintf(buffer, "CN%s%sp%s-%d-%s",
		family, core_model, pass, clock_mhz, suffix);
	return buffer;
}
Commit	Line	Data
58f07778 DD	1	/*********************license start*************
	2	* Author: Cavium Networks
	3	*
	4	* Contact: support@caviumnetworks.com
	5	* This file is part of the OCTEON SDK
	6	*
	7	* Copyright (c) 2003-2008 Cavium Networks
	8	*
	9	* This file is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License, Version 2, as
	11	* published by the Free Software Foundation.
	12	*
	13	* This file is distributed in the hope that it will be useful, but
	14	* AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
	15	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
	16	* NONINFRINGEMENT. See the GNU General Public License for more
	17	* details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this file; if not, write to the Free Software
	21	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	22	* or visit http://www.gnu.org/licenses/.
	23	*
	24	* This file may also be available under a different license from Cavium.
	25	* Contact Cavium Networks for more information
	26	*********************license end************************************/
	27
	28	/*
	29	* File defining functions for working with different Octeon
	30	* models.
	31	*/
	32	#include <asm/octeon/octeon.h>
	33
	34	/**
	35	* Given the chip processor ID from COP0, this function returns a
	36	* string representing the chip model number. The string is of the
	37	* form CNXXXXpX.X-FREQ-SUFFIX.
	38	* - XXXX = The chip model number
	39	* - X.X = Chip pass number
	40	* - FREQ = Current frequency in Mhz
	41	* - SUFFIX = NSP, EXP, SCP, SSP, or CP
	42	*
	43	* @chip_id: Chip ID
	44	*
	45	* Returns Model string
	46	*/
	47	const char *octeon_model_get_string(uint32_t chip_id)
	48	{
	49	static char buffer[32];
	50	return octeon_model_get_string_buffer(chip_id, buffer);
	51	}
	52
	53	/*
	54	* Version of octeon_model_get_string() that takes buffer as argument,
	55	* as running early in u-boot static/global variables don't work when
	56	* running from flash.
	57	*/
	58	const char octeon_model_get_string_buffer(uint32_t chip_id, char buffer)
	59	{
	60	const char *family;
	61	const char *core_model;
	62	char pass[4];
	63	int clock_mhz;
	64	const char *suffix;
65	union cvmx_l2d_fus3 fus3;
66	int num_cores;
67	union cvmx_mio_fus_dat2 fus_dat2;
68	union cvmx_mio_fus_dat3 fus_dat3;
69	char fuse_model[10];
70	uint32_t fuse_data = 0;
71
72	fus3.u64 = cvmx_read_csr(CVMX_L2D_FUS3);
73	fus_dat2.u64 = cvmx_read_csr(CVMX_MIO_FUS_DAT2);
74	fus_dat3.u64 = cvmx_read_csr(CVMX_MIO_FUS_DAT3);
75
76	num_cores = cvmx_octeon_num_cores();
77
25985edc	78	/* Make sure the non existent devices look disabled */
58f07778 DD	79	switch ((chip_id >> 8) & 0xff) {
	80	case 6: /* CN50XX */
	81	case 2: /* CN30XX */
	82	fus_dat3.s.nodfa_dte = 1;
	83	fus_dat3.s.nozip = 1;
	84	break;
	85	case 4: /* CN57XX or CN56XX */
	86	fus_dat3.s.nodfa_dte = 1;
	87	break;
	88	default:
	89	break;
	90	}
	91
	92	/* Make a guess at the suffix */
	93	/* NSP = everything */
	94	/* EXP = No crypto */
	95	/* SCP = No DFA, No zip */
	96	/* CP = No DFA, No crypto, No zip */
	97	if (fus_dat3.s.nodfa_dte) {
	98	if (fus_dat2.s.nocrypto)
	99	suffix = "CP";
	100	else
	101	suffix = "SCP";
	102	} else if (fus_dat2.s.nocrypto)
	103	suffix = "EXP";
	104	else
	105	suffix = "NSP";
	106
	107	/*
	108	* Assume pass number is encoded using <5:3><2:0>. Exceptions
	109	* will be fixed later.
	110	*/
	111	sprintf(pass, "%u.%u", ((chip_id >> 3) & 7) + 1, chip_id & 7);
	112
	113	/*
	114	* Use the number of cores to determine the last 2 digits of
	115	* the model number. There are some exceptions that are fixed
	116	* later.
	117	*/
	118	switch (num_cores) {
	119	case 16:
	120	core_model = "60";
	121	break;
	122	case 15:
	123	core_model = "58";
	124	break;
	125	case 14:
	126	core_model = "55";
	127	break;
	128	case 13:
	129	core_model = "52";
	130	break;
	131	case 12:
	132	core_model = "50";
	133	break;
	134	case 11:
	135	core_model = "48";
	136	break;
	137	case 10:
	138	core_model = "45";
	139	break;
	140	case 9:
	141	core_model = "42";
	142	break;
143	case 8:
144	core_model = "40";
145	break;
146	case 7:
147	core_model = "38";
148	break;
149	case 6:
150	core_model = "34";
151	break;
152	case 5:
153	core_model = "32";
154	break;
155	case 4:
156	core_model = "30";
157	break;
158	case 3:
159	core_model = "25";
160	break;
161	case 2:
162	core_model = "20";
163	break;
164	case 1:
165	core_model = "10";
166	break;
167	default:
168	core_model = "XX";
169	break;
170	}
171
172	/* Now figure out the family, the first two digits */
173	switch ((chip_id >> 8) & 0xff) {
174	case 0: /* CN38XX, CN37XX or CN36XX */
175	if (fus3.cn38xx.crip_512k) {
176	/*
177	* For some unknown reason, the 16 core one is
178	* called 37 instead of 36.
179	*/
180	if (num_cores >= 16)
181	family = "37";
182	else
183	family = "36";
184	} else
185	family = "38";
186	/*
187	* This series of chips didn't follow the standard
188	* pass numbering.
189	*/
190	switch (chip_id & 0xf) {
191	case 0:
192	strcpy(pass, "1.X");
193	break;
194	case 1:
195	strcpy(pass, "2.X");
196	break;
197	case 3:
198	strcpy(pass, "3.X");
199	break;
200	default:
201	strcpy(pass, "X.X");
202	break;
203	}
204	break;
205	case 1: /* CN31XX or CN3020 */
206	if ((chip_id & 0x10) \|\| fus3.cn31xx.crip_128k)
207	family = "30";
208	else
209	family = "31";
210	/*
211	* This series of chips didn't follow the standard
212	* pass numbering.
213	*/
214	switch (chip_id & 0xf) {
215	case 0:
216	strcpy(pass, "1.0");
217	break;
218	case 2:
219	strcpy(pass, "1.1");
220	break;
221	default:
222	strcpy(pass, "X.X");
223	break;
224	}
225	break;
226	case 2: /* CN3010 or CN3005 */
227	family = "30";
228	/* A chip with half cache is an 05 */
229	if (fus3.cn30xx.crip_64k)
230	core_model = "05";
231	/*
232	* This series of chips didn't follow the standard
233	* pass numbering.
234	*/
235	switch (chip_id & 0xf) {
236	case 0:
237	strcpy(pass, "1.0");
238	break;
239	case 2:
240	strcpy(pass, "1.1");
241	break;
242	default:
243	strcpy(pass, "X.X");
244	break;
245	}
246	break;
247	case 3: /* CN58XX */
248	family = "58";
249	/* Special case. 4 core, no crypto */
250	if ((num_cores == 4) && fus_dat2.cn38xx.nocrypto)
251	core_model = "29";
252
253	/* Pass 1 uses different encodings for pass numbers */
254	if ((chip_id & 0xFF) < 0x8) {
255	switch (chip_id & 0x3) {
256	case 0:
257	strcpy(pass, "1.0");
258	break;
259	case 1:
260	strcpy(pass, "1.1");
261	break;
262	case 3:
263	strcpy(pass, "1.2");
264	break;
265	default:
266	strcpy(pass, "1.X");
267	break;
268	}
269	}
270	break;
271	case 4: /* CN57XX, CN56XX, CN55XX, CN54XX */
272	if (fus_dat2.cn56xx.raid_en) {
273	if (fus3.cn56xx.crip_1024k)
274	family = "55";
275	else
276	family = "57";
277	if (fus_dat2.cn56xx.nocrypto)
278	suffix = "SP";
279	else
280	suffix = "SSP";
281	} else {
282	if (fus_dat2.cn56xx.nocrypto)
283	suffix = "CP";
284	else {
285	suffix = "NSP";
286	if (fus_dat3.s.nozip)
287	suffix = "SCP";
288	}
289	if (fus3.cn56xx.crip_1024k)
290	family = "54";
291	else
292	family = "56";
293	}
294	break;
295	case 6: /* CN50XX */
296	family = "50";
297	break;
298	case 7: /* CN52XX */
299	if (fus3.cn52xx.crip_256k)
300	family = "51";
301	else
302	family = "52";
303	break;
304	default:
305	family = "XX";
306	core_model = "XX";
307	strcpy(pass, "X.X");
308	suffix = "XXX";
309	break;
310	}
311
312	clock_mhz = octeon_get_clock_rate() / 1000000;
313
314	if (family[0] != '3') {
315	/* Check for model in fuses, overrides normal decode */
316	/* This is _not_ valid for Octeon CN3XXX models */
317	fuse_data \|= cvmx_fuse_read_byte(51);
318	fuse_data = fuse_data << 8;
319	fuse_data \|= cvmx_fuse_read_byte(50);
320	fuse_data = fuse_data << 8;
321	fuse_data \|= cvmx_fuse_read_byte(49);
322	fuse_data = fuse_data << 8;
323	fuse_data \|= cvmx_fuse_read_byte(48);
324	if (fuse_data & 0x7ffff) {
325	int model = fuse_data & 0x3fff;
326	int suffix = (fuse_data >> 14) & 0x1f;
327	if (suffix && model) {
328	/*
329	* Have both number and suffix in
330	* fuses, so both
331	*/
332	sprintf(fuse_model, "%d%c",
333	model, 'A' + suffix - 1);
334	core_model = "";
335	family = fuse_model;
336	} else if (suffix && !model) {
337	/*
338	* Only have suffix, so add suffix to
339	* 'normal' model number.
340	*/
341	sprintf(fuse_model, "%s%c", core_model,
342	'A' + suffix - 1);
343	core_model = fuse_model;
344	} else {
345	/*
346	* Don't have suffix, so just use
347	* model from fuses.
348	*/
349	sprintf(fuse_model, "%d", model);
350	core_model = "";
351	family = fuse_model;
352	}
353	}
354	}
355	sprintf(buffer, "CN%s%sp%s-%d-%s",
356	family, core_model, pass, clock_mhz, suffix);
357	return buffer;
358	}