Loading...
1// SPDX-License-Identifier: BSD-3-Clause
2/* Copyright 2016-2018 NXP
3 * Copyright (c) 2018, Sensor-Technik Wiedemann GmbH
4 * Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>
5 */
6#include <linux/spi/spi.h>
7#include <linux/packing.h>
8#include "sja1105.h"
9
10struct sja1105_chunk {
11 u8 *buf;
12 size_t len;
13 u64 reg_addr;
14};
15
16static void
17sja1105_spi_message_pack(void *buf, const struct sja1105_spi_message *msg)
18{
19 const int size = SJA1105_SIZE_SPI_MSG_HEADER;
20
21 memset(buf, 0, size);
22
23 sja1105_pack(buf, &msg->access, 31, 31, size);
24 sja1105_pack(buf, &msg->read_count, 30, 25, size);
25 sja1105_pack(buf, &msg->address, 24, 4, size);
26}
27
28/* If @rw is:
29 * - SPI_WRITE: creates and sends an SPI write message at absolute
30 * address reg_addr, taking @len bytes from *buf
31 * - SPI_READ: creates and sends an SPI read message from absolute
32 * address reg_addr, writing @len bytes into *buf
33 */
34static int sja1105_xfer(const struct sja1105_private *priv,
35 sja1105_spi_rw_mode_t rw, u64 reg_addr, u8 *buf,
36 size_t len, struct ptp_system_timestamp *ptp_sts)
37{
38 u8 hdr_buf[SJA1105_SIZE_SPI_MSG_HEADER] = {0};
39 struct spi_device *spi = priv->spidev;
40 struct spi_transfer xfers[2] = {0};
41 struct spi_transfer *chunk_xfer;
42 struct spi_transfer *hdr_xfer;
43 struct sja1105_chunk chunk;
44 int num_chunks;
45 int rc, i = 0;
46
47 num_chunks = DIV_ROUND_UP(len, priv->max_xfer_len);
48
49 chunk.reg_addr = reg_addr;
50 chunk.buf = buf;
51 chunk.len = min_t(size_t, len, priv->max_xfer_len);
52
53 hdr_xfer = &xfers[0];
54 chunk_xfer = &xfers[1];
55
56 for (i = 0; i < num_chunks; i++) {
57 struct spi_transfer *ptp_sts_xfer;
58 struct sja1105_spi_message msg;
59
60 /* Populate the transfer's header buffer */
61 msg.address = chunk.reg_addr;
62 msg.access = rw;
63 if (rw == SPI_READ)
64 msg.read_count = chunk.len / 4;
65 else
66 /* Ignored */
67 msg.read_count = 0;
68 sja1105_spi_message_pack(hdr_buf, &msg);
69 hdr_xfer->tx_buf = hdr_buf;
70 hdr_xfer->len = SJA1105_SIZE_SPI_MSG_HEADER;
71
72 /* Populate the transfer's data buffer */
73 if (rw == SPI_READ)
74 chunk_xfer->rx_buf = chunk.buf;
75 else
76 chunk_xfer->tx_buf = chunk.buf;
77 chunk_xfer->len = chunk.len;
78
79 /* Request timestamping for the transfer. Instead of letting
80 * callers specify which byte they want to timestamp, we can
81 * make certain assumptions:
82 * - A read operation will request a software timestamp when
83 * what's being read is the PTP time. That is snapshotted by
84 * the switch hardware at the end of the command portion
85 * (hdr_xfer).
86 * - A write operation will request a software timestamp on
87 * actions that modify the PTP time. Taking clock stepping as
88 * an example, the switch writes the PTP time at the end of
89 * the data portion (chunk_xfer).
90 */
91 if (rw == SPI_READ)
92 ptp_sts_xfer = hdr_xfer;
93 else
94 ptp_sts_xfer = chunk_xfer;
95 ptp_sts_xfer->ptp_sts_word_pre = ptp_sts_xfer->len - 1;
96 ptp_sts_xfer->ptp_sts_word_post = ptp_sts_xfer->len - 1;
97 ptp_sts_xfer->ptp_sts = ptp_sts;
98
99 /* Calculate next chunk */
100 chunk.buf += chunk.len;
101 chunk.reg_addr += chunk.len / 4;
102 chunk.len = min_t(size_t, (ptrdiff_t)(buf + len - chunk.buf),
103 priv->max_xfer_len);
104
105 rc = spi_sync_transfer(spi, xfers, 2);
106 if (rc < 0) {
107 dev_err(&spi->dev, "SPI transfer failed: %d\n", rc);
108 return rc;
109 }
110 }
111
112 return 0;
113}
114
115int sja1105_xfer_buf(const struct sja1105_private *priv,
116 sja1105_spi_rw_mode_t rw, u64 reg_addr,
117 u8 *buf, size_t len)
118{
119 return sja1105_xfer(priv, rw, reg_addr, buf, len, NULL);
120}
121
122/* If @rw is:
123 * - SPI_WRITE: creates and sends an SPI write message at absolute
124 * address reg_addr
125 * - SPI_READ: creates and sends an SPI read message from absolute
126 * address reg_addr
127 *
128 * The u64 *value is unpacked, meaning that it's stored in the native
129 * CPU endianness and directly usable by software running on the core.
130 */
131int sja1105_xfer_u64(const struct sja1105_private *priv,
132 sja1105_spi_rw_mode_t rw, u64 reg_addr, u64 *value,
133 struct ptp_system_timestamp *ptp_sts)
134{
135 u8 packed_buf[8];
136 int rc;
137
138 if (rw == SPI_WRITE)
139 sja1105_pack(packed_buf, value, 63, 0, 8);
140
141 rc = sja1105_xfer(priv, rw, reg_addr, packed_buf, 8, ptp_sts);
142
143 if (rw == SPI_READ)
144 sja1105_unpack(packed_buf, value, 63, 0, 8);
145
146 return rc;
147}
148
149/* Same as above, but transfers only a 4 byte word */
150int sja1105_xfer_u32(const struct sja1105_private *priv,
151 sja1105_spi_rw_mode_t rw, u64 reg_addr, u32 *value,
152 struct ptp_system_timestamp *ptp_sts)
153{
154 u8 packed_buf[4];
155 u64 tmp;
156 int rc;
157
158 if (rw == SPI_WRITE) {
159 /* The packing API only supports u64 as CPU word size,
160 * so we need to convert.
161 */
162 tmp = *value;
163 sja1105_pack(packed_buf, &tmp, 31, 0, 4);
164 }
165
166 rc = sja1105_xfer(priv, rw, reg_addr, packed_buf, 4, ptp_sts);
167
168 if (rw == SPI_READ) {
169 sja1105_unpack(packed_buf, &tmp, 31, 0, 4);
170 *value = tmp;
171 }
172
173 return rc;
174}
175
176static int sja1105et_reset_cmd(struct dsa_switch *ds)
177{
178 struct sja1105_private *priv = ds->priv;
179 const struct sja1105_regs *regs = priv->info->regs;
180 u32 cold_reset = BIT(3);
181
182 /* Cold reset */
183 return sja1105_xfer_u32(priv, SPI_WRITE, regs->rgu, &cold_reset, NULL);
184}
185
186static int sja1105pqrs_reset_cmd(struct dsa_switch *ds)
187{
188 struct sja1105_private *priv = ds->priv;
189 const struct sja1105_regs *regs = priv->info->regs;
190 u32 cold_reset = BIT(2);
191
192 /* Cold reset */
193 return sja1105_xfer_u32(priv, SPI_WRITE, regs->rgu, &cold_reset, NULL);
194}
195
196static int sja1110_reset_cmd(struct dsa_switch *ds)
197{
198 struct sja1105_private *priv = ds->priv;
199 const struct sja1105_regs *regs = priv->info->regs;
200 u32 switch_reset = BIT(20);
201
202 /* Only reset the switch core.
203 * A full cold reset would re-enable the BASE_MCSS_CLOCK PLL which
204 * would turn on the microcontroller, potentially letting it execute
205 * code which could interfere with our configuration.
206 */
207 return sja1105_xfer_u32(priv, SPI_WRITE, regs->rgu, &switch_reset, NULL);
208}
209
210int sja1105_inhibit_tx(const struct sja1105_private *priv,
211 unsigned long port_bitmap, bool tx_inhibited)
212{
213 const struct sja1105_regs *regs = priv->info->regs;
214 u32 inhibit_cmd;
215 int rc;
216
217 rc = sja1105_xfer_u32(priv, SPI_READ, regs->port_control,
218 &inhibit_cmd, NULL);
219 if (rc < 0)
220 return rc;
221
222 if (tx_inhibited)
223 inhibit_cmd |= port_bitmap;
224 else
225 inhibit_cmd &= ~port_bitmap;
226
227 return sja1105_xfer_u32(priv, SPI_WRITE, regs->port_control,
228 &inhibit_cmd, NULL);
229}
230
231struct sja1105_status {
232 u64 configs;
233 u64 crcchkl;
234 u64 ids;
235 u64 crcchkg;
236};
237
238/* This is not reading the entire General Status area, which is also
239 * divergent between E/T and P/Q/R/S, but only the relevant bits for
240 * ensuring that the static config upload procedure was successful.
241 */
242static void sja1105_status_unpack(void *buf, struct sja1105_status *status)
243{
244 /* So that addition translates to 4 bytes */
245 u32 *p = buf;
246
247 /* device_id is missing from the buffer, but we don't
248 * want to diverge from the manual definition of the
249 * register addresses, so we'll back off one step with
250 * the register pointer, and never access p[0].
251 */
252 p--;
253 sja1105_unpack(p + 0x1, &status->configs, 31, 31, 4);
254 sja1105_unpack(p + 0x1, &status->crcchkl, 30, 30, 4);
255 sja1105_unpack(p + 0x1, &status->ids, 29, 29, 4);
256 sja1105_unpack(p + 0x1, &status->crcchkg, 28, 28, 4);
257}
258
259static int sja1105_status_get(struct sja1105_private *priv,
260 struct sja1105_status *status)
261{
262 const struct sja1105_regs *regs = priv->info->regs;
263 u8 packed_buf[4];
264 int rc;
265
266 rc = sja1105_xfer_buf(priv, SPI_READ, regs->status, packed_buf, 4);
267 if (rc < 0)
268 return rc;
269
270 sja1105_status_unpack(packed_buf, status);
271
272 return 0;
273}
274
275/* Not const because unpacking priv->static_config into buffers and preparing
276 * for upload requires the recalculation of table CRCs and updating the
277 * structures with these.
278 */
279int static_config_buf_prepare_for_upload(struct sja1105_private *priv,
280 void *config_buf, int buf_len)
281{
282 struct sja1105_static_config *config = &priv->static_config;
283 struct sja1105_table_header final_header;
284 sja1105_config_valid_t valid;
285 char *final_header_ptr;
286 int crc_len;
287
288 valid = sja1105_static_config_check_valid(config,
289 priv->info->max_frame_mem);
290 if (valid != SJA1105_CONFIG_OK) {
291 dev_err(&priv->spidev->dev,
292 sja1105_static_config_error_msg[valid]);
293 return -EINVAL;
294 }
295
296 /* Write Device ID and config tables to config_buf */
297 sja1105_static_config_pack(config_buf, config);
298 /* Recalculate CRC of the last header (right now 0xDEADBEEF).
299 * Don't include the CRC field itself.
300 */
301 crc_len = buf_len - 4;
302 /* Read the whole table header */
303 final_header_ptr = config_buf + buf_len - SJA1105_SIZE_TABLE_HEADER;
304 sja1105_table_header_packing(final_header_ptr, &final_header, UNPACK);
305 /* Modify */
306 final_header.crc = sja1105_crc32(config_buf, crc_len);
307 /* Rewrite */
308 sja1105_table_header_packing(final_header_ptr, &final_header, PACK);
309
310 return 0;
311}
312
313#define RETRIES 10
314
315int sja1105_static_config_upload(struct sja1105_private *priv)
316{
317 struct sja1105_static_config *config = &priv->static_config;
318 const struct sja1105_regs *regs = priv->info->regs;
319 struct device *dev = &priv->spidev->dev;
320 struct dsa_switch *ds = priv->ds;
321 struct sja1105_status status;
322 int rc, retries = RETRIES;
323 u8 *config_buf;
324 int buf_len;
325
326 buf_len = sja1105_static_config_get_length(config);
327 config_buf = kcalloc(buf_len, sizeof(char), GFP_KERNEL);
328 if (!config_buf)
329 return -ENOMEM;
330
331 rc = static_config_buf_prepare_for_upload(priv, config_buf, buf_len);
332 if (rc < 0) {
333 dev_err(dev, "Invalid config, cannot upload\n");
334 rc = -EINVAL;
335 goto out;
336 }
337 /* Prevent PHY jabbering during switch reset by inhibiting
338 * Tx on all ports and waiting for current packet to drain.
339 * Otherwise, the PHY will see an unterminated Ethernet packet.
340 */
341 rc = sja1105_inhibit_tx(priv, GENMASK_ULL(ds->num_ports - 1, 0), true);
342 if (rc < 0) {
343 dev_err(dev, "Failed to inhibit Tx on ports\n");
344 rc = -ENXIO;
345 goto out;
346 }
347 /* Wait for an eventual egress packet to finish transmission
348 * (reach IFG). It is guaranteed that a second one will not
349 * follow, and that switch cold reset is thus safe
350 */
351 usleep_range(500, 1000);
352 do {
353 /* Put the SJA1105 in programming mode */
354 rc = priv->info->reset_cmd(priv->ds);
355 if (rc < 0) {
356 dev_err(dev, "Failed to reset switch, retrying...\n");
357 continue;
358 }
359 /* Wait for the switch to come out of reset */
360 usleep_range(1000, 5000);
361 /* Upload the static config to the device */
362 rc = sja1105_xfer_buf(priv, SPI_WRITE, regs->config,
363 config_buf, buf_len);
364 if (rc < 0) {
365 dev_err(dev, "Failed to upload config, retrying...\n");
366 continue;
367 }
368 /* Check that SJA1105 responded well to the config upload */
369 rc = sja1105_status_get(priv, &status);
370 if (rc < 0)
371 continue;
372
373 if (status.ids == 1) {
374 dev_err(dev, "Mismatch between hardware and static config "
375 "device id. Wrote 0x%llx, wants 0x%llx\n",
376 config->device_id, priv->info->device_id);
377 continue;
378 }
379 if (status.crcchkl == 1) {
380 dev_err(dev, "Switch reported invalid local CRC on "
381 "the uploaded config, retrying...\n");
382 continue;
383 }
384 if (status.crcchkg == 1) {
385 dev_err(dev, "Switch reported invalid global CRC on "
386 "the uploaded config, retrying...\n");
387 continue;
388 }
389 if (status.configs == 0) {
390 dev_err(dev, "Switch reported that configuration is "
391 "invalid, retrying...\n");
392 continue;
393 }
394 /* Success! */
395 break;
396 } while (--retries);
397
398 if (!retries) {
399 rc = -EIO;
400 dev_err(dev, "Failed to upload config to device, giving up\n");
401 goto out;
402 } else if (retries != RETRIES) {
403 dev_info(dev, "Succeeded after %d tried\n", RETRIES - retries);
404 }
405
406out:
407 kfree(config_buf);
408 return rc;
409}
410
411static const struct sja1105_regs sja1105et_regs = {
412 .device_id = 0x0,
413 .prod_id = 0x100BC3,
414 .status = 0x1,
415 .port_control = 0x11,
416 .vl_status = 0x10000,
417 .config = 0x020000,
418 .rgu = 0x100440,
419 /* UM10944.pdf, Table 86, ACU Register overview */
420 .pad_mii_tx = {0x100800, 0x100802, 0x100804, 0x100806, 0x100808},
421 .pad_mii_rx = {0x100801, 0x100803, 0x100805, 0x100807, 0x100809},
422 .rmii_pll1 = 0x10000A,
423 .cgu_idiv = {0x10000B, 0x10000C, 0x10000D, 0x10000E, 0x10000F},
424 .stats[MAC] = {0x200, 0x202, 0x204, 0x206, 0x208},
425 .stats[HL1] = {0x400, 0x410, 0x420, 0x430, 0x440},
426 .stats[HL2] = {0x600, 0x610, 0x620, 0x630, 0x640},
427 /* UM10944.pdf, Table 78, CGU Register overview */
428 .mii_tx_clk = {0x100013, 0x10001A, 0x100021, 0x100028, 0x10002F},
429 .mii_rx_clk = {0x100014, 0x10001B, 0x100022, 0x100029, 0x100030},
430 .mii_ext_tx_clk = {0x100018, 0x10001F, 0x100026, 0x10002D, 0x100034},
431 .mii_ext_rx_clk = {0x100019, 0x100020, 0x100027, 0x10002E, 0x100035},
432 .rgmii_tx_clk = {0x100016, 0x10001D, 0x100024, 0x10002B, 0x100032},
433 .rmii_ref_clk = {0x100015, 0x10001C, 0x100023, 0x10002A, 0x100031},
434 .rmii_ext_tx_clk = {0x100018, 0x10001F, 0x100026, 0x10002D, 0x100034},
435 .ptpegr_ts = {0xC0, 0xC2, 0xC4, 0xC6, 0xC8},
436 .ptpschtm = 0x12, /* Spans 0x12 to 0x13 */
437 .ptppinst = 0x14,
438 .ptppindur = 0x16,
439 .ptp_control = 0x17,
440 .ptpclkval = 0x18, /* Spans 0x18 to 0x19 */
441 .ptpclkrate = 0x1A,
442 .ptpclkcorp = 0x1D,
443 .mdio_100base_tx = SJA1105_RSV_ADDR,
444 .mdio_100base_t1 = SJA1105_RSV_ADDR,
445};
446
447static const struct sja1105_regs sja1105pqrs_regs = {
448 .device_id = 0x0,
449 .prod_id = 0x100BC3,
450 .status = 0x1,
451 .port_control = 0x12,
452 .vl_status = 0x10000,
453 .config = 0x020000,
454 .rgu = 0x100440,
455 /* UM10944.pdf, Table 86, ACU Register overview */
456 .pad_mii_tx = {0x100800, 0x100802, 0x100804, 0x100806, 0x100808},
457 .pad_mii_rx = {0x100801, 0x100803, 0x100805, 0x100807, 0x100809},
458 .pad_mii_id = {0x100810, 0x100811, 0x100812, 0x100813, 0x100814},
459 .rmii_pll1 = 0x10000A,
460 .cgu_idiv = {0x10000B, 0x10000C, 0x10000D, 0x10000E, 0x10000F},
461 .stats[MAC] = {0x200, 0x202, 0x204, 0x206, 0x208},
462 .stats[HL1] = {0x400, 0x410, 0x420, 0x430, 0x440},
463 .stats[HL2] = {0x600, 0x610, 0x620, 0x630, 0x640},
464 .stats[ETHER] = {0x1400, 0x1418, 0x1430, 0x1448, 0x1460},
465 /* UM11040.pdf, Table 114 */
466 .mii_tx_clk = {0x100013, 0x100019, 0x10001F, 0x100025, 0x10002B},
467 .mii_rx_clk = {0x100014, 0x10001A, 0x100020, 0x100026, 0x10002C},
468 .mii_ext_tx_clk = {0x100017, 0x10001D, 0x100023, 0x100029, 0x10002F},
469 .mii_ext_rx_clk = {0x100018, 0x10001E, 0x100024, 0x10002A, 0x100030},
470 .rgmii_tx_clk = {0x100016, 0x10001C, 0x100022, 0x100028, 0x10002E},
471 .rmii_ref_clk = {0x100015, 0x10001B, 0x100021, 0x100027, 0x10002D},
472 .rmii_ext_tx_clk = {0x100017, 0x10001D, 0x100023, 0x100029, 0x10002F},
473 .ptpegr_ts = {0xC0, 0xC4, 0xC8, 0xCC, 0xD0},
474 .ptpschtm = 0x13, /* Spans 0x13 to 0x14 */
475 .ptppinst = 0x15,
476 .ptppindur = 0x17,
477 .ptp_control = 0x18,
478 .ptpclkval = 0x19,
479 .ptpclkrate = 0x1B,
480 .ptpclkcorp = 0x1E,
481 .ptpsyncts = 0x1F,
482 .mdio_100base_tx = SJA1105_RSV_ADDR,
483 .mdio_100base_t1 = SJA1105_RSV_ADDR,
484};
485
486static const struct sja1105_regs sja1110_regs = {
487 .device_id = SJA1110_SPI_ADDR(0x0),
488 .prod_id = SJA1110_ACU_ADDR(0xf00),
489 .status = SJA1110_SPI_ADDR(0x4),
490 .port_control = SJA1110_SPI_ADDR(0x50), /* actually INHIB_TX */
491 .vl_status = 0x10000,
492 .config = 0x020000,
493 .rgu = SJA1110_RGU_ADDR(0x100), /* Reset Control Register 0 */
494 /* Ports 2 and 3 are capable of xMII, but there isn't anything to
495 * configure in the CGU/ACU for them.
496 */
497 .pad_mii_tx = {SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
498 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
499 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
500 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
501 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
502 SJA1105_RSV_ADDR},
503 .pad_mii_rx = {SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
504 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
505 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
506 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
507 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
508 SJA1105_RSV_ADDR},
509 .pad_mii_id = {SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
510 SJA1110_ACU_ADDR(0x18), SJA1110_ACU_ADDR(0x28),
511 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
512 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
513 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
514 SJA1105_RSV_ADDR},
515 .rmii_pll1 = SJA1105_RSV_ADDR,
516 .cgu_idiv = {SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
517 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
518 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
519 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR},
520 .stats[MAC] = {0x200, 0x202, 0x204, 0x206, 0x208, 0x20a,
521 0x20c, 0x20e, 0x210, 0x212, 0x214},
522 .stats[HL1] = {0x400, 0x410, 0x420, 0x430, 0x440, 0x450,
523 0x460, 0x470, 0x480, 0x490, 0x4a0},
524 .stats[HL2] = {0x600, 0x610, 0x620, 0x630, 0x640, 0x650,
525 0x660, 0x670, 0x680, 0x690, 0x6a0},
526 .stats[ETHER] = {0x1400, 0x1418, 0x1430, 0x1448, 0x1460, 0x1478,
527 0x1490, 0x14a8, 0x14c0, 0x14d8, 0x14f0},
528 .mii_tx_clk = {SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
529 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
530 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
531 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR},
532 .mii_rx_clk = {SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
533 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
534 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
535 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR},
536 .mii_ext_tx_clk = {SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
537 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
538 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
539 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR},
540 .mii_ext_rx_clk = {SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
541 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
542 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
543 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR},
544 .rgmii_tx_clk = {SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
545 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
546 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
547 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR},
548 .rmii_ref_clk = {SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
549 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
550 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
551 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR},
552 .rmii_ext_tx_clk = {SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
553 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
554 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
555 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
556 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
557 SJA1105_RSV_ADDR},
558 .ptpschtm = SJA1110_SPI_ADDR(0x54),
559 .ptppinst = SJA1110_SPI_ADDR(0x5c),
560 .ptppindur = SJA1110_SPI_ADDR(0x64),
561 .ptp_control = SJA1110_SPI_ADDR(0x68),
562 .ptpclkval = SJA1110_SPI_ADDR(0x6c),
563 .ptpclkrate = SJA1110_SPI_ADDR(0x74),
564 .ptpclkcorp = SJA1110_SPI_ADDR(0x80),
565 .ptpsyncts = SJA1110_SPI_ADDR(0x84),
566 .mdio_100base_tx = 0x1c2400,
567 .mdio_100base_t1 = 0x1c1000,
568 .pcs_base = {SJA1105_RSV_ADDR, 0x1c1400, 0x1c1800, 0x1c1c00, 0x1c2000,
569 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR,
570 SJA1105_RSV_ADDR, SJA1105_RSV_ADDR, SJA1105_RSV_ADDR},
571};
572
573const struct sja1105_info sja1105e_info = {
574 .device_id = SJA1105E_DEVICE_ID,
575 .part_no = SJA1105ET_PART_NO,
576 .static_ops = sja1105e_table_ops,
577 .dyn_ops = sja1105et_dyn_ops,
578 .tag_proto = DSA_TAG_PROTO_SJA1105,
579 .can_limit_mcast_flood = false,
580 .ptp_ts_bits = 24,
581 .ptpegr_ts_bytes = 4,
582 .max_frame_mem = SJA1105_MAX_FRAME_MEMORY,
583 .num_ports = SJA1105_NUM_PORTS,
584 .num_cbs_shapers = SJA1105ET_MAX_CBS_COUNT,
585 .reset_cmd = sja1105et_reset_cmd,
586 .fdb_add_cmd = sja1105et_fdb_add,
587 .fdb_del_cmd = sja1105et_fdb_del,
588 .ptp_cmd_packing = sja1105et_ptp_cmd_packing,
589 .rxtstamp = sja1105_rxtstamp,
590 .clocking_setup = sja1105_clocking_setup,
591 .regs = &sja1105et_regs,
592 .port_speed = {
593 [SJA1105_SPEED_AUTO] = 0,
594 [SJA1105_SPEED_10MBPS] = 3,
595 [SJA1105_SPEED_100MBPS] = 2,
596 [SJA1105_SPEED_1000MBPS] = 1,
597 [SJA1105_SPEED_2500MBPS] = 0, /* Not supported */
598 },
599 .supports_mii = {true, true, true, true, true},
600 .supports_rmii = {true, true, true, true, true},
601 .supports_rgmii = {true, true, true, true, true},
602 .name = "SJA1105E",
603};
604
605const struct sja1105_info sja1105t_info = {
606 .device_id = SJA1105T_DEVICE_ID,
607 .part_no = SJA1105ET_PART_NO,
608 .static_ops = sja1105t_table_ops,
609 .dyn_ops = sja1105et_dyn_ops,
610 .tag_proto = DSA_TAG_PROTO_SJA1105,
611 .can_limit_mcast_flood = false,
612 .ptp_ts_bits = 24,
613 .ptpegr_ts_bytes = 4,
614 .max_frame_mem = SJA1105_MAX_FRAME_MEMORY,
615 .num_ports = SJA1105_NUM_PORTS,
616 .num_cbs_shapers = SJA1105ET_MAX_CBS_COUNT,
617 .reset_cmd = sja1105et_reset_cmd,
618 .fdb_add_cmd = sja1105et_fdb_add,
619 .fdb_del_cmd = sja1105et_fdb_del,
620 .ptp_cmd_packing = sja1105et_ptp_cmd_packing,
621 .rxtstamp = sja1105_rxtstamp,
622 .clocking_setup = sja1105_clocking_setup,
623 .regs = &sja1105et_regs,
624 .port_speed = {
625 [SJA1105_SPEED_AUTO] = 0,
626 [SJA1105_SPEED_10MBPS] = 3,
627 [SJA1105_SPEED_100MBPS] = 2,
628 [SJA1105_SPEED_1000MBPS] = 1,
629 [SJA1105_SPEED_2500MBPS] = 0, /* Not supported */
630 },
631 .supports_mii = {true, true, true, true, true},
632 .supports_rmii = {true, true, true, true, true},
633 .supports_rgmii = {true, true, true, true, true},
634 .name = "SJA1105T",
635};
636
637const struct sja1105_info sja1105p_info = {
638 .device_id = SJA1105PR_DEVICE_ID,
639 .part_no = SJA1105P_PART_NO,
640 .static_ops = sja1105p_table_ops,
641 .dyn_ops = sja1105pqrs_dyn_ops,
642 .tag_proto = DSA_TAG_PROTO_SJA1105,
643 .can_limit_mcast_flood = true,
644 .ptp_ts_bits = 32,
645 .ptpegr_ts_bytes = 8,
646 .max_frame_mem = SJA1105_MAX_FRAME_MEMORY,
647 .num_ports = SJA1105_NUM_PORTS,
648 .num_cbs_shapers = SJA1105PQRS_MAX_CBS_COUNT,
649 .setup_rgmii_delay = sja1105pqrs_setup_rgmii_delay,
650 .reset_cmd = sja1105pqrs_reset_cmd,
651 .fdb_add_cmd = sja1105pqrs_fdb_add,
652 .fdb_del_cmd = sja1105pqrs_fdb_del,
653 .ptp_cmd_packing = sja1105pqrs_ptp_cmd_packing,
654 .rxtstamp = sja1105_rxtstamp,
655 .clocking_setup = sja1105_clocking_setup,
656 .regs = &sja1105pqrs_regs,
657 .port_speed = {
658 [SJA1105_SPEED_AUTO] = 0,
659 [SJA1105_SPEED_10MBPS] = 3,
660 [SJA1105_SPEED_100MBPS] = 2,
661 [SJA1105_SPEED_1000MBPS] = 1,
662 [SJA1105_SPEED_2500MBPS] = 0, /* Not supported */
663 },
664 .supports_mii = {true, true, true, true, true},
665 .supports_rmii = {true, true, true, true, true},
666 .supports_rgmii = {true, true, true, true, true},
667 .name = "SJA1105P",
668};
669
670const struct sja1105_info sja1105q_info = {
671 .device_id = SJA1105QS_DEVICE_ID,
672 .part_no = SJA1105Q_PART_NO,
673 .static_ops = sja1105q_table_ops,
674 .dyn_ops = sja1105pqrs_dyn_ops,
675 .tag_proto = DSA_TAG_PROTO_SJA1105,
676 .can_limit_mcast_flood = true,
677 .ptp_ts_bits = 32,
678 .ptpegr_ts_bytes = 8,
679 .max_frame_mem = SJA1105_MAX_FRAME_MEMORY,
680 .num_ports = SJA1105_NUM_PORTS,
681 .num_cbs_shapers = SJA1105PQRS_MAX_CBS_COUNT,
682 .setup_rgmii_delay = sja1105pqrs_setup_rgmii_delay,
683 .reset_cmd = sja1105pqrs_reset_cmd,
684 .fdb_add_cmd = sja1105pqrs_fdb_add,
685 .fdb_del_cmd = sja1105pqrs_fdb_del,
686 .ptp_cmd_packing = sja1105pqrs_ptp_cmd_packing,
687 .rxtstamp = sja1105_rxtstamp,
688 .clocking_setup = sja1105_clocking_setup,
689 .regs = &sja1105pqrs_regs,
690 .port_speed = {
691 [SJA1105_SPEED_AUTO] = 0,
692 [SJA1105_SPEED_10MBPS] = 3,
693 [SJA1105_SPEED_100MBPS] = 2,
694 [SJA1105_SPEED_1000MBPS] = 1,
695 [SJA1105_SPEED_2500MBPS] = 0, /* Not supported */
696 },
697 .supports_mii = {true, true, true, true, true},
698 .supports_rmii = {true, true, true, true, true},
699 .supports_rgmii = {true, true, true, true, true},
700 .name = "SJA1105Q",
701};
702
703const struct sja1105_info sja1105r_info = {
704 .device_id = SJA1105PR_DEVICE_ID,
705 .part_no = SJA1105R_PART_NO,
706 .static_ops = sja1105r_table_ops,
707 .dyn_ops = sja1105pqrs_dyn_ops,
708 .tag_proto = DSA_TAG_PROTO_SJA1105,
709 .can_limit_mcast_flood = true,
710 .ptp_ts_bits = 32,
711 .ptpegr_ts_bytes = 8,
712 .max_frame_mem = SJA1105_MAX_FRAME_MEMORY,
713 .num_ports = SJA1105_NUM_PORTS,
714 .num_cbs_shapers = SJA1105PQRS_MAX_CBS_COUNT,
715 .setup_rgmii_delay = sja1105pqrs_setup_rgmii_delay,
716 .reset_cmd = sja1105pqrs_reset_cmd,
717 .fdb_add_cmd = sja1105pqrs_fdb_add,
718 .fdb_del_cmd = sja1105pqrs_fdb_del,
719 .ptp_cmd_packing = sja1105pqrs_ptp_cmd_packing,
720 .rxtstamp = sja1105_rxtstamp,
721 .clocking_setup = sja1105_clocking_setup,
722 .pcs_mdio_read_c45 = sja1105_pcs_mdio_read_c45,
723 .pcs_mdio_write_c45 = sja1105_pcs_mdio_write_c45,
724 .regs = &sja1105pqrs_regs,
725 .port_speed = {
726 [SJA1105_SPEED_AUTO] = 0,
727 [SJA1105_SPEED_10MBPS] = 3,
728 [SJA1105_SPEED_100MBPS] = 2,
729 [SJA1105_SPEED_1000MBPS] = 1,
730 [SJA1105_SPEED_2500MBPS] = 0, /* Not supported */
731 },
732 .supports_mii = {true, true, true, true, true},
733 .supports_rmii = {true, true, true, true, true},
734 .supports_rgmii = {true, true, true, true, true},
735 .supports_sgmii = {false, false, false, false, true},
736 .name = "SJA1105R",
737};
738
739const struct sja1105_info sja1105s_info = {
740 .device_id = SJA1105QS_DEVICE_ID,
741 .part_no = SJA1105S_PART_NO,
742 .static_ops = sja1105s_table_ops,
743 .dyn_ops = sja1105pqrs_dyn_ops,
744 .regs = &sja1105pqrs_regs,
745 .tag_proto = DSA_TAG_PROTO_SJA1105,
746 .can_limit_mcast_flood = true,
747 .ptp_ts_bits = 32,
748 .ptpegr_ts_bytes = 8,
749 .max_frame_mem = SJA1105_MAX_FRAME_MEMORY,
750 .num_ports = SJA1105_NUM_PORTS,
751 .num_cbs_shapers = SJA1105PQRS_MAX_CBS_COUNT,
752 .setup_rgmii_delay = sja1105pqrs_setup_rgmii_delay,
753 .reset_cmd = sja1105pqrs_reset_cmd,
754 .fdb_add_cmd = sja1105pqrs_fdb_add,
755 .fdb_del_cmd = sja1105pqrs_fdb_del,
756 .ptp_cmd_packing = sja1105pqrs_ptp_cmd_packing,
757 .rxtstamp = sja1105_rxtstamp,
758 .clocking_setup = sja1105_clocking_setup,
759 .pcs_mdio_read_c45 = sja1105_pcs_mdio_read_c45,
760 .pcs_mdio_write_c45 = sja1105_pcs_mdio_write_c45,
761 .port_speed = {
762 [SJA1105_SPEED_AUTO] = 0,
763 [SJA1105_SPEED_10MBPS] = 3,
764 [SJA1105_SPEED_100MBPS] = 2,
765 [SJA1105_SPEED_1000MBPS] = 1,
766 [SJA1105_SPEED_2500MBPS] = 0, /* Not supported */
767 },
768 .supports_mii = {true, true, true, true, true},
769 .supports_rmii = {true, true, true, true, true},
770 .supports_rgmii = {true, true, true, true, true},
771 .supports_sgmii = {false, false, false, false, true},
772 .name = "SJA1105S",
773};
774
775const struct sja1105_info sja1110a_info = {
776 .device_id = SJA1110_DEVICE_ID,
777 .part_no = SJA1110A_PART_NO,
778 .static_ops = sja1110_table_ops,
779 .dyn_ops = sja1110_dyn_ops,
780 .regs = &sja1110_regs,
781 .tag_proto = DSA_TAG_PROTO_SJA1110,
782 .can_limit_mcast_flood = true,
783 .multiple_cascade_ports = true,
784 .fixed_cbs_mapping = true,
785 .ptp_ts_bits = 32,
786 .ptpegr_ts_bytes = 8,
787 .max_frame_mem = SJA1110_MAX_FRAME_MEMORY,
788 .num_ports = SJA1110_NUM_PORTS,
789 .num_cbs_shapers = SJA1110_MAX_CBS_COUNT,
790 .setup_rgmii_delay = sja1110_setup_rgmii_delay,
791 .reset_cmd = sja1110_reset_cmd,
792 .fdb_add_cmd = sja1105pqrs_fdb_add,
793 .fdb_del_cmd = sja1105pqrs_fdb_del,
794 .ptp_cmd_packing = sja1105pqrs_ptp_cmd_packing,
795 .rxtstamp = sja1110_rxtstamp,
796 .txtstamp = sja1110_txtstamp,
797 .disable_microcontroller = sja1110_disable_microcontroller,
798 .pcs_mdio_read_c45 = sja1110_pcs_mdio_read_c45,
799 .pcs_mdio_write_c45 = sja1110_pcs_mdio_write_c45,
800 .port_speed = {
801 [SJA1105_SPEED_AUTO] = 0,
802 [SJA1105_SPEED_10MBPS] = 4,
803 [SJA1105_SPEED_100MBPS] = 3,
804 [SJA1105_SPEED_1000MBPS] = 2,
805 [SJA1105_SPEED_2500MBPS] = 1,
806 },
807 .supports_mii = {true, true, true, true, false,
808 true, true, true, true, true, true},
809 .supports_rmii = {false, false, true, true, false,
810 false, false, false, false, false, false},
811 .supports_rgmii = {false, false, true, true, false,
812 false, false, false, false, false, false},
813 .supports_sgmii = {false, true, true, true, true,
814 false, false, false, false, false, false},
815 .supports_2500basex = {false, false, false, true, true,
816 false, false, false, false, false, false},
817 .internal_phy = {SJA1105_NO_PHY, SJA1105_PHY_BASE_TX,
818 SJA1105_NO_PHY, SJA1105_NO_PHY,
819 SJA1105_NO_PHY, SJA1105_PHY_BASE_T1,
820 SJA1105_PHY_BASE_T1, SJA1105_PHY_BASE_T1,
821 SJA1105_PHY_BASE_T1, SJA1105_PHY_BASE_T1,
822 SJA1105_PHY_BASE_T1},
823 .name = "SJA1110A",
824};
825
826const struct sja1105_info sja1110b_info = {
827 .device_id = SJA1110_DEVICE_ID,
828 .part_no = SJA1110B_PART_NO,
829 .static_ops = sja1110_table_ops,
830 .dyn_ops = sja1110_dyn_ops,
831 .regs = &sja1110_regs,
832 .tag_proto = DSA_TAG_PROTO_SJA1110,
833 .can_limit_mcast_flood = true,
834 .multiple_cascade_ports = true,
835 .fixed_cbs_mapping = true,
836 .ptp_ts_bits = 32,
837 .ptpegr_ts_bytes = 8,
838 .max_frame_mem = SJA1110_MAX_FRAME_MEMORY,
839 .num_ports = SJA1110_NUM_PORTS,
840 .num_cbs_shapers = SJA1110_MAX_CBS_COUNT,
841 .setup_rgmii_delay = sja1110_setup_rgmii_delay,
842 .reset_cmd = sja1110_reset_cmd,
843 .fdb_add_cmd = sja1105pqrs_fdb_add,
844 .fdb_del_cmd = sja1105pqrs_fdb_del,
845 .ptp_cmd_packing = sja1105pqrs_ptp_cmd_packing,
846 .rxtstamp = sja1110_rxtstamp,
847 .txtstamp = sja1110_txtstamp,
848 .disable_microcontroller = sja1110_disable_microcontroller,
849 .pcs_mdio_read_c45 = sja1110_pcs_mdio_read_c45,
850 .pcs_mdio_write_c45 = sja1110_pcs_mdio_write_c45,
851 .port_speed = {
852 [SJA1105_SPEED_AUTO] = 0,
853 [SJA1105_SPEED_10MBPS] = 4,
854 [SJA1105_SPEED_100MBPS] = 3,
855 [SJA1105_SPEED_1000MBPS] = 2,
856 [SJA1105_SPEED_2500MBPS] = 1,
857 },
858 .supports_mii = {true, true, true, true, false,
859 true, true, true, true, true, false},
860 .supports_rmii = {false, false, true, true, false,
861 false, false, false, false, false, false},
862 .supports_rgmii = {false, false, true, true, false,
863 false, false, false, false, false, false},
864 .supports_sgmii = {false, false, false, true, true,
865 false, false, false, false, false, false},
866 .supports_2500basex = {false, false, false, true, true,
867 false, false, false, false, false, false},
868 .internal_phy = {SJA1105_NO_PHY, SJA1105_PHY_BASE_TX,
869 SJA1105_NO_PHY, SJA1105_NO_PHY,
870 SJA1105_NO_PHY, SJA1105_PHY_BASE_T1,
871 SJA1105_PHY_BASE_T1, SJA1105_PHY_BASE_T1,
872 SJA1105_PHY_BASE_T1, SJA1105_PHY_BASE_T1,
873 SJA1105_NO_PHY},
874 .name = "SJA1110B",
875};
876
877const struct sja1105_info sja1110c_info = {
878 .device_id = SJA1110_DEVICE_ID,
879 .part_no = SJA1110C_PART_NO,
880 .static_ops = sja1110_table_ops,
881 .dyn_ops = sja1110_dyn_ops,
882 .regs = &sja1110_regs,
883 .tag_proto = DSA_TAG_PROTO_SJA1110,
884 .can_limit_mcast_flood = true,
885 .multiple_cascade_ports = true,
886 .fixed_cbs_mapping = true,
887 .ptp_ts_bits = 32,
888 .ptpegr_ts_bytes = 8,
889 .max_frame_mem = SJA1110_MAX_FRAME_MEMORY,
890 .num_ports = SJA1110_NUM_PORTS,
891 .num_cbs_shapers = SJA1110_MAX_CBS_COUNT,
892 .setup_rgmii_delay = sja1110_setup_rgmii_delay,
893 .reset_cmd = sja1110_reset_cmd,
894 .fdb_add_cmd = sja1105pqrs_fdb_add,
895 .fdb_del_cmd = sja1105pqrs_fdb_del,
896 .ptp_cmd_packing = sja1105pqrs_ptp_cmd_packing,
897 .rxtstamp = sja1110_rxtstamp,
898 .txtstamp = sja1110_txtstamp,
899 .disable_microcontroller = sja1110_disable_microcontroller,
900 .pcs_mdio_read_c45 = sja1110_pcs_mdio_read_c45,
901 .pcs_mdio_write_c45 = sja1110_pcs_mdio_write_c45,
902 .port_speed = {
903 [SJA1105_SPEED_AUTO] = 0,
904 [SJA1105_SPEED_10MBPS] = 4,
905 [SJA1105_SPEED_100MBPS] = 3,
906 [SJA1105_SPEED_1000MBPS] = 2,
907 [SJA1105_SPEED_2500MBPS] = 1,
908 },
909 .supports_mii = {true, true, true, true, false,
910 true, true, true, false, false, false},
911 .supports_rmii = {false, false, true, true, false,
912 false, false, false, false, false, false},
913 .supports_rgmii = {false, false, true, true, false,
914 false, false, false, false, false, false},
915 .supports_sgmii = {false, false, false, false, true,
916 false, false, false, false, false, false},
917 .supports_2500basex = {false, false, false, false, true,
918 false, false, false, false, false, false},
919 .internal_phy = {SJA1105_NO_PHY, SJA1105_PHY_BASE_TX,
920 SJA1105_NO_PHY, SJA1105_NO_PHY,
921 SJA1105_NO_PHY, SJA1105_PHY_BASE_T1,
922 SJA1105_PHY_BASE_T1, SJA1105_PHY_BASE_T1,
923 SJA1105_NO_PHY, SJA1105_NO_PHY,
924 SJA1105_NO_PHY},
925 .name = "SJA1110C",
926};
927
928const struct sja1105_info sja1110d_info = {
929 .device_id = SJA1110_DEVICE_ID,
930 .part_no = SJA1110D_PART_NO,
931 .static_ops = sja1110_table_ops,
932 .dyn_ops = sja1110_dyn_ops,
933 .regs = &sja1110_regs,
934 .tag_proto = DSA_TAG_PROTO_SJA1110,
935 .can_limit_mcast_flood = true,
936 .multiple_cascade_ports = true,
937 .fixed_cbs_mapping = true,
938 .ptp_ts_bits = 32,
939 .ptpegr_ts_bytes = 8,
940 .max_frame_mem = SJA1110_MAX_FRAME_MEMORY,
941 .num_ports = SJA1110_NUM_PORTS,
942 .num_cbs_shapers = SJA1110_MAX_CBS_COUNT,
943 .setup_rgmii_delay = sja1110_setup_rgmii_delay,
944 .reset_cmd = sja1110_reset_cmd,
945 .fdb_add_cmd = sja1105pqrs_fdb_add,
946 .fdb_del_cmd = sja1105pqrs_fdb_del,
947 .ptp_cmd_packing = sja1105pqrs_ptp_cmd_packing,
948 .rxtstamp = sja1110_rxtstamp,
949 .txtstamp = sja1110_txtstamp,
950 .disable_microcontroller = sja1110_disable_microcontroller,
951 .pcs_mdio_read_c45 = sja1110_pcs_mdio_read_c45,
952 .pcs_mdio_write_c45 = sja1110_pcs_mdio_write_c45,
953 .port_speed = {
954 [SJA1105_SPEED_AUTO] = 0,
955 [SJA1105_SPEED_10MBPS] = 4,
956 [SJA1105_SPEED_100MBPS] = 3,
957 [SJA1105_SPEED_1000MBPS] = 2,
958 [SJA1105_SPEED_2500MBPS] = 1,
959 },
960 .supports_mii = {true, false, true, false, false,
961 true, true, true, false, false, false},
962 .supports_rmii = {false, false, true, false, false,
963 false, false, false, false, false, false},
964 .supports_rgmii = {false, false, true, false, false,
965 false, false, false, false, false, false},
966 .supports_sgmii = {false, true, true, true, true,
967 false, false, false, false, false, false},
968 .supports_2500basex = {false, false, false, true, true,
969 false, false, false, false, false, false},
970 .internal_phy = {SJA1105_NO_PHY, SJA1105_NO_PHY,
971 SJA1105_NO_PHY, SJA1105_NO_PHY,
972 SJA1105_NO_PHY, SJA1105_PHY_BASE_T1,
973 SJA1105_PHY_BASE_T1, SJA1105_PHY_BASE_T1,
974 SJA1105_NO_PHY, SJA1105_NO_PHY,
975 SJA1105_NO_PHY},
976 .name = "SJA1110D",
977};
1// SPDX-License-Identifier: BSD-3-Clause
2/* Copyright (c) 2016-2018, NXP Semiconductors
3 * Copyright (c) 2018, Sensor-Technik Wiedemann GmbH
4 * Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>
5 */
6#include <linux/spi/spi.h>
7#include <linux/packing.h>
8#include "sja1105.h"
9
10#define SJA1105_SIZE_PORT_CTRL 4
11#define SJA1105_SIZE_RESET_CMD 4
12#define SJA1105_SIZE_SPI_MSG_HEADER 4
13#define SJA1105_SIZE_SPI_MSG_MAXLEN (64 * 4)
14#define SJA1105_SIZE_SPI_TRANSFER_MAX \
15 (SJA1105_SIZE_SPI_MSG_HEADER + SJA1105_SIZE_SPI_MSG_MAXLEN)
16
17static int sja1105_spi_transfer(const struct sja1105_private *priv,
18 const void *tx, void *rx, int size)
19{
20 struct spi_device *spi = priv->spidev;
21 struct spi_transfer transfer = {
22 .tx_buf = tx,
23 .rx_buf = rx,
24 .len = size,
25 };
26 struct spi_message msg;
27 int rc;
28
29 if (size > SJA1105_SIZE_SPI_TRANSFER_MAX) {
30 dev_err(&spi->dev, "SPI message (%d) longer than max of %d\n",
31 size, SJA1105_SIZE_SPI_TRANSFER_MAX);
32 return -EMSGSIZE;
33 }
34
35 spi_message_init(&msg);
36 spi_message_add_tail(&transfer, &msg);
37
38 rc = spi_sync(spi, &msg);
39 if (rc < 0) {
40 dev_err(&spi->dev, "SPI transfer failed: %d\n", rc);
41 return rc;
42 }
43
44 return rc;
45}
46
47static void
48sja1105_spi_message_pack(void *buf, const struct sja1105_spi_message *msg)
49{
50 const int size = SJA1105_SIZE_SPI_MSG_HEADER;
51
52 memset(buf, 0, size);
53
54 sja1105_pack(buf, &msg->access, 31, 31, size);
55 sja1105_pack(buf, &msg->read_count, 30, 25, size);
56 sja1105_pack(buf, &msg->address, 24, 4, size);
57}
58
59/* If @rw is:
60 * - SPI_WRITE: creates and sends an SPI write message at absolute
61 * address reg_addr, taking size_bytes from *packed_buf
62 * - SPI_READ: creates and sends an SPI read message from absolute
63 * address reg_addr, writing size_bytes into *packed_buf
64 *
65 * This function should only be called if it is priorly known that
66 * @size_bytes is smaller than SIZE_SPI_MSG_MAXLEN. Larger packed buffers
67 * are chunked in smaller pieces by sja1105_spi_send_long_packed_buf below.
68 */
69int sja1105_spi_send_packed_buf(const struct sja1105_private *priv,
70 sja1105_spi_rw_mode_t rw, u64 reg_addr,
71 void *packed_buf, size_t size_bytes)
72{
73 u8 tx_buf[SJA1105_SIZE_SPI_TRANSFER_MAX] = {0};
74 u8 rx_buf[SJA1105_SIZE_SPI_TRANSFER_MAX] = {0};
75 const int msg_len = size_bytes + SJA1105_SIZE_SPI_MSG_HEADER;
76 struct sja1105_spi_message msg = {0};
77 int rc;
78
79 if (msg_len > SJA1105_SIZE_SPI_TRANSFER_MAX)
80 return -ERANGE;
81
82 msg.access = rw;
83 msg.address = reg_addr;
84 if (rw == SPI_READ)
85 msg.read_count = size_bytes / 4;
86
87 sja1105_spi_message_pack(tx_buf, &msg);
88
89 if (rw == SPI_WRITE)
90 memcpy(tx_buf + SJA1105_SIZE_SPI_MSG_HEADER,
91 packed_buf, size_bytes);
92
93 rc = sja1105_spi_transfer(priv, tx_buf, rx_buf, msg_len);
94 if (rc < 0)
95 return rc;
96
97 if (rw == SPI_READ)
98 memcpy(packed_buf, rx_buf + SJA1105_SIZE_SPI_MSG_HEADER,
99 size_bytes);
100
101 return 0;
102}
103
104/* If @rw is:
105 * - SPI_WRITE: creates and sends an SPI write message at absolute
106 * address reg_addr, taking size_bytes from *packed_buf
107 * - SPI_READ: creates and sends an SPI read message from absolute
108 * address reg_addr, writing size_bytes into *packed_buf
109 *
110 * The u64 *value is unpacked, meaning that it's stored in the native
111 * CPU endianness and directly usable by software running on the core.
112 *
113 * This is a wrapper around sja1105_spi_send_packed_buf().
114 */
115int sja1105_spi_send_int(const struct sja1105_private *priv,
116 sja1105_spi_rw_mode_t rw, u64 reg_addr,
117 u64 *value, u64 size_bytes)
118{
119 u8 packed_buf[SJA1105_SIZE_SPI_MSG_MAXLEN];
120 int rc;
121
122 if (size_bytes > SJA1105_SIZE_SPI_MSG_MAXLEN)
123 return -ERANGE;
124
125 if (rw == SPI_WRITE)
126 sja1105_pack(packed_buf, value, 8 * size_bytes - 1, 0,
127 size_bytes);
128
129 rc = sja1105_spi_send_packed_buf(priv, rw, reg_addr, packed_buf,
130 size_bytes);
131
132 if (rw == SPI_READ)
133 sja1105_unpack(packed_buf, value, 8 * size_bytes - 1, 0,
134 size_bytes);
135
136 return rc;
137}
138
139/* Should be used if a @packed_buf larger than SJA1105_SIZE_SPI_MSG_MAXLEN
140 * must be sent/received. Splitting the buffer into chunks and assembling
141 * those into SPI messages is done automatically by this function.
142 */
143int sja1105_spi_send_long_packed_buf(const struct sja1105_private *priv,
144 sja1105_spi_rw_mode_t rw, u64 base_addr,
145 void *packed_buf, u64 buf_len)
146{
147 struct chunk {
148 void *buf_ptr;
149 int len;
150 u64 spi_address;
151 } chunk;
152 int distance_to_end;
153 int rc;
154
155 /* Initialize chunk */
156 chunk.buf_ptr = packed_buf;
157 chunk.spi_address = base_addr;
158 chunk.len = min_t(int, buf_len, SJA1105_SIZE_SPI_MSG_MAXLEN);
159
160 while (chunk.len) {
161 rc = sja1105_spi_send_packed_buf(priv, rw, chunk.spi_address,
162 chunk.buf_ptr, chunk.len);
163 if (rc < 0)
164 return rc;
165
166 chunk.buf_ptr += chunk.len;
167 chunk.spi_address += chunk.len / 4;
168 distance_to_end = (uintptr_t)(packed_buf + buf_len -
169 chunk.buf_ptr);
170 chunk.len = min(distance_to_end, SJA1105_SIZE_SPI_MSG_MAXLEN);
171 }
172
173 return 0;
174}
175
176/* Back-ported structure from UM11040 Table 112.
177 * Reset control register (addr. 100440h)
178 * In the SJA1105 E/T, only warm_rst and cold_rst are
179 * supported (exposed in UM10944 as rst_ctrl), but the bit
180 * offsets of warm_rst and cold_rst are actually reversed.
181 */
182struct sja1105_reset_cmd {
183 u64 switch_rst;
184 u64 cfg_rst;
185 u64 car_rst;
186 u64 otp_rst;
187 u64 warm_rst;
188 u64 cold_rst;
189 u64 por_rst;
190};
191
192static void
193sja1105et_reset_cmd_pack(void *buf, const struct sja1105_reset_cmd *reset)
194{
195 const int size = SJA1105_SIZE_RESET_CMD;
196
197 memset(buf, 0, size);
198
199 sja1105_pack(buf, &reset->cold_rst, 3, 3, size);
200 sja1105_pack(buf, &reset->warm_rst, 2, 2, size);
201}
202
203static void
204sja1105pqrs_reset_cmd_pack(void *buf, const struct sja1105_reset_cmd *reset)
205{
206 const int size = SJA1105_SIZE_RESET_CMD;
207
208 memset(buf, 0, size);
209
210 sja1105_pack(buf, &reset->switch_rst, 8, 8, size);
211 sja1105_pack(buf, &reset->cfg_rst, 7, 7, size);
212 sja1105_pack(buf, &reset->car_rst, 5, 5, size);
213 sja1105_pack(buf, &reset->otp_rst, 4, 4, size);
214 sja1105_pack(buf, &reset->warm_rst, 3, 3, size);
215 sja1105_pack(buf, &reset->cold_rst, 2, 2, size);
216 sja1105_pack(buf, &reset->por_rst, 1, 1, size);
217}
218
219static int sja1105et_reset_cmd(const void *ctx, const void *data)
220{
221 const struct sja1105_private *priv = ctx;
222 const struct sja1105_reset_cmd *reset = data;
223 const struct sja1105_regs *regs = priv->info->regs;
224 struct device *dev = priv->ds->dev;
225 u8 packed_buf[SJA1105_SIZE_RESET_CMD];
226
227 if (reset->switch_rst ||
228 reset->cfg_rst ||
229 reset->car_rst ||
230 reset->otp_rst ||
231 reset->por_rst) {
232 dev_err(dev, "Only warm and cold reset is supported "
233 "for SJA1105 E/T!\n");
234 return -EINVAL;
235 }
236
237 if (reset->warm_rst)
238 dev_dbg(dev, "Warm reset requested\n");
239 if (reset->cold_rst)
240 dev_dbg(dev, "Cold reset requested\n");
241
242 sja1105et_reset_cmd_pack(packed_buf, reset);
243
244 return sja1105_spi_send_packed_buf(priv, SPI_WRITE, regs->rgu,
245 packed_buf, SJA1105_SIZE_RESET_CMD);
246}
247
248static int sja1105pqrs_reset_cmd(const void *ctx, const void *data)
249{
250 const struct sja1105_private *priv = ctx;
251 const struct sja1105_reset_cmd *reset = data;
252 const struct sja1105_regs *regs = priv->info->regs;
253 struct device *dev = priv->ds->dev;
254 u8 packed_buf[SJA1105_SIZE_RESET_CMD];
255
256 if (reset->switch_rst)
257 dev_dbg(dev, "Main reset for all functional modules requested\n");
258 if (reset->cfg_rst)
259 dev_dbg(dev, "Chip configuration reset requested\n");
260 if (reset->car_rst)
261 dev_dbg(dev, "Clock and reset control logic reset requested\n");
262 if (reset->otp_rst)
263 dev_dbg(dev, "OTP read cycle for reading product "
264 "config settings requested\n");
265 if (reset->warm_rst)
266 dev_dbg(dev, "Warm reset requested\n");
267 if (reset->cold_rst)
268 dev_dbg(dev, "Cold reset requested\n");
269 if (reset->por_rst)
270 dev_dbg(dev, "Power-on reset requested\n");
271
272 sja1105pqrs_reset_cmd_pack(packed_buf, reset);
273
274 return sja1105_spi_send_packed_buf(priv, SPI_WRITE, regs->rgu,
275 packed_buf, SJA1105_SIZE_RESET_CMD);
276}
277
278static int sja1105_cold_reset(const struct sja1105_private *priv)
279{
280 struct sja1105_reset_cmd reset = {0};
281
282 reset.cold_rst = 1;
283 return priv->info->reset_cmd(priv, &reset);
284}
285
286int sja1105_inhibit_tx(const struct sja1105_private *priv,
287 unsigned long port_bitmap, bool tx_inhibited)
288{
289 const struct sja1105_regs *regs = priv->info->regs;
290 u64 inhibit_cmd;
291 int rc;
292
293 rc = sja1105_spi_send_int(priv, SPI_READ, regs->port_control,
294 &inhibit_cmd, SJA1105_SIZE_PORT_CTRL);
295 if (rc < 0)
296 return rc;
297
298 if (tx_inhibited)
299 inhibit_cmd |= port_bitmap;
300 else
301 inhibit_cmd &= ~port_bitmap;
302
303 return sja1105_spi_send_int(priv, SPI_WRITE, regs->port_control,
304 &inhibit_cmd, SJA1105_SIZE_PORT_CTRL);
305}
306
307struct sja1105_status {
308 u64 configs;
309 u64 crcchkl;
310 u64 ids;
311 u64 crcchkg;
312};
313
314/* This is not reading the entire General Status area, which is also
315 * divergent between E/T and P/Q/R/S, but only the relevant bits for
316 * ensuring that the static config upload procedure was successful.
317 */
318static void sja1105_status_unpack(void *buf, struct sja1105_status *status)
319{
320 /* So that addition translates to 4 bytes */
321 u32 *p = buf;
322
323 /* device_id is missing from the buffer, but we don't
324 * want to diverge from the manual definition of the
325 * register addresses, so we'll back off one step with
326 * the register pointer, and never access p[0].
327 */
328 p--;
329 sja1105_unpack(p + 0x1, &status->configs, 31, 31, 4);
330 sja1105_unpack(p + 0x1, &status->crcchkl, 30, 30, 4);
331 sja1105_unpack(p + 0x1, &status->ids, 29, 29, 4);
332 sja1105_unpack(p + 0x1, &status->crcchkg, 28, 28, 4);
333}
334
335static int sja1105_status_get(struct sja1105_private *priv,
336 struct sja1105_status *status)
337{
338 const struct sja1105_regs *regs = priv->info->regs;
339 u8 packed_buf[4];
340 int rc;
341
342 rc = sja1105_spi_send_packed_buf(priv, SPI_READ,
343 regs->status,
344 packed_buf, 4);
345 if (rc < 0)
346 return rc;
347
348 sja1105_status_unpack(packed_buf, status);
349
350 return 0;
351}
352
353/* Not const because unpacking priv->static_config into buffers and preparing
354 * for upload requires the recalculation of table CRCs and updating the
355 * structures with these.
356 */
357static int
358static_config_buf_prepare_for_upload(struct sja1105_private *priv,
359 void *config_buf, int buf_len)
360{
361 struct sja1105_static_config *config = &priv->static_config;
362 struct sja1105_table_header final_header;
363 sja1105_config_valid_t valid;
364 char *final_header_ptr;
365 int crc_len;
366
367 valid = sja1105_static_config_check_valid(config);
368 if (valid != SJA1105_CONFIG_OK) {
369 dev_err(&priv->spidev->dev,
370 sja1105_static_config_error_msg[valid]);
371 return -EINVAL;
372 }
373
374 /* Write Device ID and config tables to config_buf */
375 sja1105_static_config_pack(config_buf, config);
376 /* Recalculate CRC of the last header (right now 0xDEADBEEF).
377 * Don't include the CRC field itself.
378 */
379 crc_len = buf_len - 4;
380 /* Read the whole table header */
381 final_header_ptr = config_buf + buf_len - SJA1105_SIZE_TABLE_HEADER;
382 sja1105_table_header_packing(final_header_ptr, &final_header, UNPACK);
383 /* Modify */
384 final_header.crc = sja1105_crc32(config_buf, crc_len);
385 /* Rewrite */
386 sja1105_table_header_packing(final_header_ptr, &final_header, PACK);
387
388 return 0;
389}
390
391#define RETRIES 10
392
393int sja1105_static_config_upload(struct sja1105_private *priv)
394{
395 unsigned long port_bitmap = GENMASK_ULL(SJA1105_NUM_PORTS - 1, 0);
396 struct sja1105_static_config *config = &priv->static_config;
397 const struct sja1105_regs *regs = priv->info->regs;
398 struct device *dev = &priv->spidev->dev;
399 struct sja1105_status status;
400 int rc, retries = RETRIES;
401 u8 *config_buf;
402 int buf_len;
403
404 buf_len = sja1105_static_config_get_length(config);
405 config_buf = kcalloc(buf_len, sizeof(char), GFP_KERNEL);
406 if (!config_buf)
407 return -ENOMEM;
408
409 rc = static_config_buf_prepare_for_upload(priv, config_buf, buf_len);
410 if (rc < 0) {
411 dev_err(dev, "Invalid config, cannot upload\n");
412 rc = -EINVAL;
413 goto out;
414 }
415 /* Prevent PHY jabbering during switch reset by inhibiting
416 * Tx on all ports and waiting for current packet to drain.
417 * Otherwise, the PHY will see an unterminated Ethernet packet.
418 */
419 rc = sja1105_inhibit_tx(priv, port_bitmap, true);
420 if (rc < 0) {
421 dev_err(dev, "Failed to inhibit Tx on ports\n");
422 rc = -ENXIO;
423 goto out;
424 }
425 /* Wait for an eventual egress packet to finish transmission
426 * (reach IFG). It is guaranteed that a second one will not
427 * follow, and that switch cold reset is thus safe
428 */
429 usleep_range(500, 1000);
430 do {
431 /* Put the SJA1105 in programming mode */
432 rc = sja1105_cold_reset(priv);
433 if (rc < 0) {
434 dev_err(dev, "Failed to reset switch, retrying...\n");
435 continue;
436 }
437 /* Wait for the switch to come out of reset */
438 usleep_range(1000, 5000);
439 /* Upload the static config to the device */
440 rc = sja1105_spi_send_long_packed_buf(priv, SPI_WRITE,
441 regs->config,
442 config_buf, buf_len);
443 if (rc < 0) {
444 dev_err(dev, "Failed to upload config, retrying...\n");
445 continue;
446 }
447 /* Check that SJA1105 responded well to the config upload */
448 rc = sja1105_status_get(priv, &status);
449 if (rc < 0)
450 continue;
451
452 if (status.ids == 1) {
453 dev_err(dev, "Mismatch between hardware and static config "
454 "device id. Wrote 0x%llx, wants 0x%llx\n",
455 config->device_id, priv->info->device_id);
456 continue;
457 }
458 if (status.crcchkl == 1) {
459 dev_err(dev, "Switch reported invalid local CRC on "
460 "the uploaded config, retrying...\n");
461 continue;
462 }
463 if (status.crcchkg == 1) {
464 dev_err(dev, "Switch reported invalid global CRC on "
465 "the uploaded config, retrying...\n");
466 continue;
467 }
468 if (status.configs == 0) {
469 dev_err(dev, "Switch reported that configuration is "
470 "invalid, retrying...\n");
471 continue;
472 }
473 /* Success! */
474 break;
475 } while (--retries);
476
477 if (!retries) {
478 rc = -EIO;
479 dev_err(dev, "Failed to upload config to device, giving up\n");
480 goto out;
481 } else if (retries != RETRIES) {
482 dev_info(dev, "Succeeded after %d tried\n", RETRIES - retries);
483 }
484
485 rc = sja1105_ptp_reset(priv);
486 if (rc < 0)
487 dev_err(dev, "Failed to reset PTP clock: %d\n", rc);
488
489 dev_info(dev, "Reset switch and programmed static config\n");
490
491out:
492 kfree(config_buf);
493 return rc;
494}
495
496static struct sja1105_regs sja1105et_regs = {
497 .device_id = 0x0,
498 .prod_id = 0x100BC3,
499 .status = 0x1,
500 .port_control = 0x11,
501 .config = 0x020000,
502 .rgu = 0x100440,
503 /* UM10944.pdf, Table 86, ACU Register overview */
504 .pad_mii_tx = {0x100800, 0x100802, 0x100804, 0x100806, 0x100808},
505 .rmii_pll1 = 0x10000A,
506 .cgu_idiv = {0x10000B, 0x10000C, 0x10000D, 0x10000E, 0x10000F},
507 .mac = {0x200, 0x202, 0x204, 0x206, 0x208},
508 .mac_hl1 = {0x400, 0x410, 0x420, 0x430, 0x440},
509 .mac_hl2 = {0x600, 0x610, 0x620, 0x630, 0x640},
510 /* UM10944.pdf, Table 78, CGU Register overview */
511 .mii_tx_clk = {0x100013, 0x10001A, 0x100021, 0x100028, 0x10002F},
512 .mii_rx_clk = {0x100014, 0x10001B, 0x100022, 0x100029, 0x100030},
513 .mii_ext_tx_clk = {0x100018, 0x10001F, 0x100026, 0x10002D, 0x100034},
514 .mii_ext_rx_clk = {0x100019, 0x100020, 0x100027, 0x10002E, 0x100035},
515 .rgmii_tx_clk = {0x100016, 0x10001D, 0x100024, 0x10002B, 0x100032},
516 .rmii_ref_clk = {0x100015, 0x10001C, 0x100023, 0x10002A, 0x100031},
517 .rmii_ext_tx_clk = {0x100018, 0x10001F, 0x100026, 0x10002D, 0x100034},
518 .ptpegr_ts = {0xC0, 0xC2, 0xC4, 0xC6, 0xC8},
519 .ptp_control = 0x17,
520 .ptpclk = 0x18, /* Spans 0x18 to 0x19 */
521 .ptpclkrate = 0x1A,
522 .ptptsclk = 0x1B, /* Spans 0x1B to 0x1C */
523};
524
525static struct sja1105_regs sja1105pqrs_regs = {
526 .device_id = 0x0,
527 .prod_id = 0x100BC3,
528 .status = 0x1,
529 .port_control = 0x12,
530 .config = 0x020000,
531 .rgu = 0x100440,
532 /* UM10944.pdf, Table 86, ACU Register overview */
533 .pad_mii_tx = {0x100800, 0x100802, 0x100804, 0x100806, 0x100808},
534 .pad_mii_id = {0x100810, 0x100811, 0x100812, 0x100813, 0x100814},
535 .rmii_pll1 = 0x10000A,
536 .cgu_idiv = {0x10000B, 0x10000C, 0x10000D, 0x10000E, 0x10000F},
537 .mac = {0x200, 0x202, 0x204, 0x206, 0x208},
538 .mac_hl1 = {0x400, 0x410, 0x420, 0x430, 0x440},
539 .mac_hl2 = {0x600, 0x610, 0x620, 0x630, 0x640},
540 /* UM11040.pdf, Table 114 */
541 .mii_tx_clk = {0x100013, 0x100019, 0x10001F, 0x100025, 0x10002B},
542 .mii_rx_clk = {0x100014, 0x10001A, 0x100020, 0x100026, 0x10002C},
543 .mii_ext_tx_clk = {0x100017, 0x10001D, 0x100023, 0x100029, 0x10002F},
544 .mii_ext_rx_clk = {0x100018, 0x10001E, 0x100024, 0x10002A, 0x100030},
545 .rgmii_tx_clk = {0x100016, 0x10001C, 0x100022, 0x100028, 0x10002E},
546 .rmii_ref_clk = {0x100015, 0x10001B, 0x100021, 0x100027, 0x10002D},
547 .rmii_ext_tx_clk = {0x100017, 0x10001D, 0x100023, 0x100029, 0x10002F},
548 .qlevel = {0x604, 0x614, 0x624, 0x634, 0x644},
549 .ptpegr_ts = {0xC0, 0xC4, 0xC8, 0xCC, 0xD0},
550 .ptp_control = 0x18,
551 .ptpclk = 0x19,
552 .ptpclkrate = 0x1B,
553 .ptptsclk = 0x1C,
554};
555
556struct sja1105_info sja1105e_info = {
557 .device_id = SJA1105E_DEVICE_ID,
558 .part_no = SJA1105ET_PART_NO,
559 .static_ops = sja1105e_table_ops,
560 .dyn_ops = sja1105et_dyn_ops,
561 .ptp_ts_bits = 24,
562 .ptpegr_ts_bytes = 4,
563 .reset_cmd = sja1105et_reset_cmd,
564 .fdb_add_cmd = sja1105et_fdb_add,
565 .fdb_del_cmd = sja1105et_fdb_del,
566 .ptp_cmd = sja1105et_ptp_cmd,
567 .regs = &sja1105et_regs,
568 .name = "SJA1105E",
569};
570struct sja1105_info sja1105t_info = {
571 .device_id = SJA1105T_DEVICE_ID,
572 .part_no = SJA1105ET_PART_NO,
573 .static_ops = sja1105t_table_ops,
574 .dyn_ops = sja1105et_dyn_ops,
575 .ptp_ts_bits = 24,
576 .ptpegr_ts_bytes = 4,
577 .reset_cmd = sja1105et_reset_cmd,
578 .fdb_add_cmd = sja1105et_fdb_add,
579 .fdb_del_cmd = sja1105et_fdb_del,
580 .ptp_cmd = sja1105et_ptp_cmd,
581 .regs = &sja1105et_regs,
582 .name = "SJA1105T",
583};
584struct sja1105_info sja1105p_info = {
585 .device_id = SJA1105PR_DEVICE_ID,
586 .part_no = SJA1105P_PART_NO,
587 .static_ops = sja1105p_table_ops,
588 .dyn_ops = sja1105pqrs_dyn_ops,
589 .ptp_ts_bits = 32,
590 .ptpegr_ts_bytes = 8,
591 .setup_rgmii_delay = sja1105pqrs_setup_rgmii_delay,
592 .reset_cmd = sja1105pqrs_reset_cmd,
593 .fdb_add_cmd = sja1105pqrs_fdb_add,
594 .fdb_del_cmd = sja1105pqrs_fdb_del,
595 .ptp_cmd = sja1105pqrs_ptp_cmd,
596 .regs = &sja1105pqrs_regs,
597 .name = "SJA1105P",
598};
599struct sja1105_info sja1105q_info = {
600 .device_id = SJA1105QS_DEVICE_ID,
601 .part_no = SJA1105Q_PART_NO,
602 .static_ops = sja1105q_table_ops,
603 .dyn_ops = sja1105pqrs_dyn_ops,
604 .ptp_ts_bits = 32,
605 .ptpegr_ts_bytes = 8,
606 .setup_rgmii_delay = sja1105pqrs_setup_rgmii_delay,
607 .reset_cmd = sja1105pqrs_reset_cmd,
608 .fdb_add_cmd = sja1105pqrs_fdb_add,
609 .fdb_del_cmd = sja1105pqrs_fdb_del,
610 .ptp_cmd = sja1105pqrs_ptp_cmd,
611 .regs = &sja1105pqrs_regs,
612 .name = "SJA1105Q",
613};
614struct sja1105_info sja1105r_info = {
615 .device_id = SJA1105PR_DEVICE_ID,
616 .part_no = SJA1105R_PART_NO,
617 .static_ops = sja1105r_table_ops,
618 .dyn_ops = sja1105pqrs_dyn_ops,
619 .ptp_ts_bits = 32,
620 .ptpegr_ts_bytes = 8,
621 .setup_rgmii_delay = sja1105pqrs_setup_rgmii_delay,
622 .reset_cmd = sja1105pqrs_reset_cmd,
623 .fdb_add_cmd = sja1105pqrs_fdb_add,
624 .fdb_del_cmd = sja1105pqrs_fdb_del,
625 .ptp_cmd = sja1105pqrs_ptp_cmd,
626 .regs = &sja1105pqrs_regs,
627 .name = "SJA1105R",
628};
629struct sja1105_info sja1105s_info = {
630 .device_id = SJA1105QS_DEVICE_ID,
631 .part_no = SJA1105S_PART_NO,
632 .static_ops = sja1105s_table_ops,
633 .dyn_ops = sja1105pqrs_dyn_ops,
634 .regs = &sja1105pqrs_regs,
635 .ptp_ts_bits = 32,
636 .ptpegr_ts_bytes = 8,
637 .setup_rgmii_delay = sja1105pqrs_setup_rgmii_delay,
638 .reset_cmd = sja1105pqrs_reset_cmd,
639 .fdb_add_cmd = sja1105pqrs_fdb_add,
640 .fdb_del_cmd = sja1105pqrs_fdb_del,
641 .ptp_cmd = sja1105pqrs_ptp_cmd,
642 .name = "SJA1105S",
643};