1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* drivers/net/ethernet/micrel/ks8851.c |
3 | * |
4 | * Copyright 2009 Simtec Electronics |
5 | * http://www.simtec.co.uk/ |
6 | * Ben Dooks <ben@simtec.co.uk> |
7 | */ |
8 | |
9 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
10 | |
11 | #include <linux/interrupt.h> |
12 | #include <linux/module.h> |
13 | #include <linux/kernel.h> |
14 | #include <linux/netdevice.h> |
15 | #include <linux/etherdevice.h> |
16 | #include <linux/ethtool.h> |
17 | #include <linux/cache.h> |
18 | #include <linux/crc32.h> |
19 | #include <linux/mii.h> |
20 | #include <linux/regulator/consumer.h> |
21 | |
22 | #include <linux/spi/spi.h> |
23 | #include <linux/gpio.h> |
24 | #include <linux/of_gpio.h> |
25 | #include <linux/of_net.h> |
26 | |
27 | #include "ks8851.h" |
28 | |
29 | static int msg_enable; |
30 | |
31 | /** |
32 | * struct ks8851_net_spi - KS8851 SPI driver private data |
33 | * @lock: Lock to ensure that the device is not accessed when busy. |
34 | * @tx_work: Work queue for tx packets |
35 | * @ks8851: KS8851 driver common private data |
36 | * @spidev: The spi device we're bound to. |
37 | * @spi_msg1: pre-setup SPI transfer with one message, @spi_xfer1. |
38 | * @spi_msg2: pre-setup SPI transfer with two messages, @spi_xfer2. |
39 | * @spi_xfer1: @spi_msg1 SPI transfer structure |
40 | * @spi_xfer2: @spi_msg2 SPI transfer structure |
41 | * |
42 | * The @lock ensures that the chip is protected when certain operations are |
43 | * in progress. When the read or write packet transfer is in progress, most |
44 | * of the chip registers are not ccessible until the transfer is finished and |
45 | * the DMA has been de-asserted. |
46 | */ |
47 | struct ks8851_net_spi { |
48 | struct ks8851_net ks8851; |
49 | struct mutex lock; |
50 | struct work_struct tx_work; |
51 | struct spi_device *spidev; |
52 | struct spi_message spi_msg1; |
53 | struct spi_message spi_msg2; |
54 | struct spi_transfer spi_xfer1; |
55 | struct spi_transfer spi_xfer2[2]; |
56 | }; |
57 | |
58 | #define to_ks8851_spi(ks) container_of((ks), struct ks8851_net_spi, ks8851) |
59 | |
60 | /* SPI frame opcodes */ |
61 | #define KS_SPIOP_RD 0x00 |
62 | #define KS_SPIOP_WR 0x40 |
63 | #define KS_SPIOP_RXFIFO 0x80 |
64 | #define KS_SPIOP_TXFIFO 0xC0 |
65 | |
66 | /* shift for byte-enable data */ |
67 | #define BYTE_EN(_x) ((_x) << 2) |
68 | |
69 | /* turn register number and byte-enable mask into data for start of packet */ |
70 | #define MK_OP(_byteen, _reg) \ |
71 | (BYTE_EN(_byteen) | (_reg) << (8 + 2) | (_reg) >> 6) |
72 | |
73 | /** |
74 | * ks8851_lock_spi - register access lock |
75 | * @ks: The chip state |
76 | * @flags: Spinlock flags |
77 | * |
78 | * Claim chip register access lock |
79 | */ |
80 | static void ks8851_lock_spi(struct ks8851_net *ks, unsigned long *flags) |
81 | { |
82 | struct ks8851_net_spi *kss = to_ks8851_spi(ks); |
83 | |
84 | mutex_lock(&kss->lock); |
85 | } |
86 | |
87 | /** |
88 | * ks8851_unlock_spi - register access unlock |
89 | * @ks: The chip state |
90 | * @flags: Spinlock flags |
91 | * |
92 | * Release chip register access lock |
93 | */ |
94 | static void ks8851_unlock_spi(struct ks8851_net *ks, unsigned long *flags) |
95 | { |
96 | struct ks8851_net_spi *kss = to_ks8851_spi(ks); |
97 | |
98 | mutex_unlock(lock: &kss->lock); |
99 | } |
100 | |
101 | /* SPI register read/write calls. |
102 | * |
103 | * All these calls issue SPI transactions to access the chip's registers. They |
104 | * all require that the necessary lock is held to prevent accesses when the |
105 | * chip is busy transferring packet data (RX/TX FIFO accesses). |
106 | */ |
107 | |
108 | /** |
109 | * ks8851_wrreg16_spi - write 16bit register value to chip via SPI |
110 | * @ks: The chip state |
111 | * @reg: The register address |
112 | * @val: The value to write |
113 | * |
114 | * Issue a write to put the value @val into the register specified in @reg. |
115 | */ |
116 | static void ks8851_wrreg16_spi(struct ks8851_net *ks, unsigned int reg, |
117 | unsigned int val) |
118 | { |
119 | struct ks8851_net_spi *kss = to_ks8851_spi(ks); |
120 | struct spi_transfer *xfer = &kss->spi_xfer1; |
121 | struct spi_message *msg = &kss->spi_msg1; |
122 | __le16 txb[2]; |
123 | int ret; |
124 | |
125 | txb[0] = cpu_to_le16(MK_OP(reg & 2 ? 0xC : 0x03, reg) | KS_SPIOP_WR); |
126 | txb[1] = cpu_to_le16(val); |
127 | |
128 | xfer->tx_buf = txb; |
129 | xfer->rx_buf = NULL; |
130 | xfer->len = 4; |
131 | |
132 | ret = spi_sync(spi: kss->spidev, message: msg); |
133 | if (ret < 0) |
134 | netdev_err(dev: ks->netdev, format: "spi_sync() failed\n" ); |
135 | } |
136 | |
137 | /** |
138 | * ks8851_rdreg - issue read register command and return the data |
139 | * @ks: The device state |
140 | * @op: The register address and byte enables in message format. |
141 | * @rxb: The RX buffer to return the result into |
142 | * @rxl: The length of data expected. |
143 | * |
144 | * This is the low level read call that issues the necessary spi message(s) |
145 | * to read data from the register specified in @op. |
146 | */ |
147 | static void ks8851_rdreg(struct ks8851_net *ks, unsigned int op, |
148 | u8 *rxb, unsigned int rxl) |
149 | { |
150 | struct ks8851_net_spi *kss = to_ks8851_spi(ks); |
151 | struct spi_transfer *xfer; |
152 | struct spi_message *msg; |
153 | __le16 *txb = (__le16 *)ks->txd; |
154 | u8 *trx = ks->rxd; |
155 | int ret; |
156 | |
157 | txb[0] = cpu_to_le16(op | KS_SPIOP_RD); |
158 | |
159 | if (kss->spidev->controller->flags & SPI_CONTROLLER_HALF_DUPLEX) { |
160 | msg = &kss->spi_msg2; |
161 | xfer = kss->spi_xfer2; |
162 | |
163 | xfer->tx_buf = txb; |
164 | xfer->rx_buf = NULL; |
165 | xfer->len = 2; |
166 | |
167 | xfer++; |
168 | xfer->tx_buf = NULL; |
169 | xfer->rx_buf = trx; |
170 | xfer->len = rxl; |
171 | } else { |
172 | msg = &kss->spi_msg1; |
173 | xfer = &kss->spi_xfer1; |
174 | |
175 | xfer->tx_buf = txb; |
176 | xfer->rx_buf = trx; |
177 | xfer->len = rxl + 2; |
178 | } |
179 | |
180 | ret = spi_sync(spi: kss->spidev, message: msg); |
181 | if (ret < 0) |
182 | netdev_err(dev: ks->netdev, format: "read: spi_sync() failed\n" ); |
183 | else if (kss->spidev->controller->flags & SPI_CONTROLLER_HALF_DUPLEX) |
184 | memcpy(rxb, trx, rxl); |
185 | else |
186 | memcpy(rxb, trx + 2, rxl); |
187 | } |
188 | |
189 | /** |
190 | * ks8851_rdreg16_spi - read 16 bit register from device via SPI |
191 | * @ks: The chip information |
192 | * @reg: The register address |
193 | * |
194 | * Read a 16bit register from the chip, returning the result |
195 | */ |
196 | static unsigned int ks8851_rdreg16_spi(struct ks8851_net *ks, unsigned int reg) |
197 | { |
198 | __le16 rx = 0; |
199 | |
200 | ks8851_rdreg(ks, MK_OP(reg & 2 ? 0xC : 0x3, reg), rxb: (u8 *)&rx, rxl: 2); |
201 | return le16_to_cpu(rx); |
202 | } |
203 | |
204 | /** |
205 | * ks8851_rdfifo_spi - read data from the receive fifo via SPI |
206 | * @ks: The device state. |
207 | * @buff: The buffer address |
208 | * @len: The length of the data to read |
209 | * |
210 | * Issue an RXQ FIFO read command and read the @len amount of data from |
211 | * the FIFO into the buffer specified by @buff. |
212 | */ |
213 | static void ks8851_rdfifo_spi(struct ks8851_net *ks, u8 *buff, unsigned int len) |
214 | { |
215 | struct ks8851_net_spi *kss = to_ks8851_spi(ks); |
216 | struct spi_transfer *xfer = kss->spi_xfer2; |
217 | struct spi_message *msg = &kss->spi_msg2; |
218 | u8 txb[1]; |
219 | int ret; |
220 | |
221 | netif_dbg(ks, rx_status, ks->netdev, |
222 | "%s: %d@%p\n" , __func__, len, buff); |
223 | |
224 | /* set the operation we're issuing */ |
225 | txb[0] = KS_SPIOP_RXFIFO; |
226 | |
227 | xfer->tx_buf = txb; |
228 | xfer->rx_buf = NULL; |
229 | xfer->len = 1; |
230 | |
231 | xfer++; |
232 | xfer->rx_buf = buff; |
233 | xfer->tx_buf = NULL; |
234 | xfer->len = len; |
235 | |
236 | ret = spi_sync(spi: kss->spidev, message: msg); |
237 | if (ret < 0) |
238 | netdev_err(dev: ks->netdev, format: "%s: spi_sync() failed\n" , __func__); |
239 | } |
240 | |
241 | /** |
242 | * ks8851_wrfifo_spi - write packet to TX FIFO via SPI |
243 | * @ks: The device state. |
244 | * @txp: The sk_buff to transmit. |
245 | * @irq: IRQ on completion of the packet. |
246 | * |
247 | * Send the @txp to the chip. This means creating the relevant packet header |
248 | * specifying the length of the packet and the other information the chip |
249 | * needs, such as IRQ on completion. Send the header and the packet data to |
250 | * the device. |
251 | */ |
252 | static void ks8851_wrfifo_spi(struct ks8851_net *ks, struct sk_buff *txp, |
253 | bool irq) |
254 | { |
255 | struct ks8851_net_spi *kss = to_ks8851_spi(ks); |
256 | struct spi_transfer *xfer = kss->spi_xfer2; |
257 | struct spi_message *msg = &kss->spi_msg2; |
258 | unsigned int fid = 0; |
259 | int ret; |
260 | |
261 | netif_dbg(ks, tx_queued, ks->netdev, "%s: skb %p, %d@%p, irq %d\n" , |
262 | __func__, txp, txp->len, txp->data, irq); |
263 | |
264 | fid = ks->fid++; |
265 | fid &= TXFR_TXFID_MASK; |
266 | |
267 | if (irq) |
268 | fid |= TXFR_TXIC; /* irq on completion */ |
269 | |
270 | /* start header at txb[1] to align txw entries */ |
271 | ks->txh.txb[1] = KS_SPIOP_TXFIFO; |
272 | ks->txh.txw[1] = cpu_to_le16(fid); |
273 | ks->txh.txw[2] = cpu_to_le16(txp->len); |
274 | |
275 | xfer->tx_buf = &ks->txh.txb[1]; |
276 | xfer->rx_buf = NULL; |
277 | xfer->len = 5; |
278 | |
279 | xfer++; |
280 | xfer->tx_buf = txp->data; |
281 | xfer->rx_buf = NULL; |
282 | xfer->len = ALIGN(txp->len, 4); |
283 | |
284 | ret = spi_sync(spi: kss->spidev, message: msg); |
285 | if (ret < 0) |
286 | netdev_err(dev: ks->netdev, format: "%s: spi_sync() failed\n" , __func__); |
287 | } |
288 | |
289 | /** |
290 | * calc_txlen - calculate size of message to send packet |
291 | * @len: Length of data |
292 | * |
293 | * Returns the size of the TXFIFO message needed to send |
294 | * this packet. |
295 | */ |
296 | static unsigned int calc_txlen(unsigned int len) |
297 | { |
298 | return ALIGN(len + 4, 4); |
299 | } |
300 | |
301 | /** |
302 | * ks8851_tx_work - process tx packet(s) |
303 | * @work: The work strucutre what was scheduled. |
304 | * |
305 | * This is called when a number of packets have been scheduled for |
306 | * transmission and need to be sent to the device. |
307 | */ |
308 | static void ks8851_tx_work(struct work_struct *work) |
309 | { |
310 | unsigned int dequeued_len = 0; |
311 | struct ks8851_net_spi *kss; |
312 | unsigned short tx_space; |
313 | struct ks8851_net *ks; |
314 | unsigned long flags; |
315 | struct sk_buff *txb; |
316 | bool last; |
317 | |
318 | kss = container_of(work, struct ks8851_net_spi, tx_work); |
319 | ks = &kss->ks8851; |
320 | last = skb_queue_empty(list: &ks->txq); |
321 | |
322 | ks8851_lock_spi(ks, flags: &flags); |
323 | |
324 | while (!last) { |
325 | txb = skb_dequeue(list: &ks->txq); |
326 | last = skb_queue_empty(list: &ks->txq); |
327 | |
328 | if (txb) { |
329 | dequeued_len += calc_txlen(len: txb->len); |
330 | |
331 | ks8851_wrreg16_spi(ks, KS_RXQCR, |
332 | val: ks->rc_rxqcr | RXQCR_SDA); |
333 | ks8851_wrfifo_spi(ks, txp: txb, irq: last); |
334 | ks8851_wrreg16_spi(ks, KS_RXQCR, val: ks->rc_rxqcr); |
335 | ks8851_wrreg16_spi(ks, KS_TXQCR, TXQCR_METFE); |
336 | |
337 | ks8851_done_tx(ks, txb); |
338 | } |
339 | } |
340 | |
341 | tx_space = ks8851_rdreg16_spi(ks, KS_TXMIR); |
342 | |
343 | spin_lock(lock: &ks->statelock); |
344 | ks->queued_len -= dequeued_len; |
345 | ks->tx_space = tx_space; |
346 | spin_unlock(lock: &ks->statelock); |
347 | |
348 | ks8851_unlock_spi(ks, flags: &flags); |
349 | } |
350 | |
351 | /** |
352 | * ks8851_flush_tx_work_spi - flush outstanding TX work |
353 | * @ks: The device state |
354 | */ |
355 | static void ks8851_flush_tx_work_spi(struct ks8851_net *ks) |
356 | { |
357 | struct ks8851_net_spi *kss = to_ks8851_spi(ks); |
358 | |
359 | flush_work(work: &kss->tx_work); |
360 | } |
361 | |
362 | /** |
363 | * ks8851_start_xmit_spi - transmit packet using SPI |
364 | * @skb: The buffer to transmit |
365 | * @dev: The device used to transmit the packet. |
366 | * |
367 | * Called by the network layer to transmit the @skb. Queue the packet for |
368 | * the device and schedule the necessary work to transmit the packet when |
369 | * it is free. |
370 | * |
371 | * We do this to firstly avoid sleeping with the network device locked, |
372 | * and secondly so we can round up more than one packet to transmit which |
373 | * means we can try and avoid generating too many transmit done interrupts. |
374 | */ |
375 | static netdev_tx_t ks8851_start_xmit_spi(struct sk_buff *skb, |
376 | struct net_device *dev) |
377 | { |
378 | unsigned int needed = calc_txlen(len: skb->len); |
379 | struct ks8851_net *ks = netdev_priv(dev); |
380 | netdev_tx_t ret = NETDEV_TX_OK; |
381 | struct ks8851_net_spi *kss; |
382 | |
383 | kss = to_ks8851_spi(ks); |
384 | |
385 | netif_dbg(ks, tx_queued, ks->netdev, |
386 | "%s: skb %p, %d@%p\n" , __func__, skb, skb->len, skb->data); |
387 | |
388 | spin_lock(lock: &ks->statelock); |
389 | |
390 | if (ks->queued_len + needed > ks->tx_space) { |
391 | netif_stop_queue(dev); |
392 | ret = NETDEV_TX_BUSY; |
393 | } else { |
394 | ks->queued_len += needed; |
395 | skb_queue_tail(list: &ks->txq, newsk: skb); |
396 | } |
397 | |
398 | spin_unlock(lock: &ks->statelock); |
399 | if (ret == NETDEV_TX_OK) |
400 | schedule_work(work: &kss->tx_work); |
401 | |
402 | return ret; |
403 | } |
404 | |
405 | static int ks8851_probe_spi(struct spi_device *spi) |
406 | { |
407 | struct device *dev = &spi->dev; |
408 | struct ks8851_net_spi *kss; |
409 | struct net_device *netdev; |
410 | struct ks8851_net *ks; |
411 | |
412 | netdev = devm_alloc_etherdev(dev, sizeof(struct ks8851_net_spi)); |
413 | if (!netdev) |
414 | return -ENOMEM; |
415 | |
416 | spi->bits_per_word = 8; |
417 | |
418 | kss = netdev_priv(dev: netdev); |
419 | ks = &kss->ks8851; |
420 | |
421 | ks->lock = ks8851_lock_spi; |
422 | ks->unlock = ks8851_unlock_spi; |
423 | ks->rdreg16 = ks8851_rdreg16_spi; |
424 | ks->wrreg16 = ks8851_wrreg16_spi; |
425 | ks->rdfifo = ks8851_rdfifo_spi; |
426 | ks->wrfifo = ks8851_wrfifo_spi; |
427 | ks->start_xmit = ks8851_start_xmit_spi; |
428 | ks->flush_tx_work = ks8851_flush_tx_work_spi; |
429 | |
430 | #define STD_IRQ (IRQ_LCI | /* Link Change */ \ |
431 | IRQ_TXI | /* TX done */ \ |
432 | IRQ_RXI | /* RX done */ \ |
433 | IRQ_SPIBEI | /* SPI bus error */ \ |
434 | IRQ_TXPSI | /* TX process stop */ \ |
435 | IRQ_RXPSI) /* RX process stop */ |
436 | ks->rc_ier = STD_IRQ; |
437 | |
438 | kss->spidev = spi; |
439 | mutex_init(&kss->lock); |
440 | INIT_WORK(&kss->tx_work, ks8851_tx_work); |
441 | |
442 | /* initialise pre-made spi transfer messages */ |
443 | spi_message_init(m: &kss->spi_msg1); |
444 | spi_message_add_tail(t: &kss->spi_xfer1, m: &kss->spi_msg1); |
445 | |
446 | spi_message_init(m: &kss->spi_msg2); |
447 | spi_message_add_tail(t: &kss->spi_xfer2[0], m: &kss->spi_msg2); |
448 | spi_message_add_tail(t: &kss->spi_xfer2[1], m: &kss->spi_msg2); |
449 | |
450 | netdev->irq = spi->irq; |
451 | |
452 | return ks8851_probe_common(netdev, dev, msg_en: msg_enable); |
453 | } |
454 | |
455 | static void ks8851_remove_spi(struct spi_device *spi) |
456 | { |
457 | ks8851_remove_common(dev: &spi->dev); |
458 | } |
459 | |
460 | static const struct of_device_id ks8851_match_table[] = { |
461 | { .compatible = "micrel,ks8851" }, |
462 | { } |
463 | }; |
464 | MODULE_DEVICE_TABLE(of, ks8851_match_table); |
465 | |
466 | static struct spi_driver ks8851_driver = { |
467 | .driver = { |
468 | .name = "ks8851" , |
469 | .of_match_table = ks8851_match_table, |
470 | .pm = &ks8851_pm_ops, |
471 | }, |
472 | .probe = ks8851_probe_spi, |
473 | .remove = ks8851_remove_spi, |
474 | }; |
475 | module_spi_driver(ks8851_driver); |
476 | |
477 | MODULE_DESCRIPTION("KS8851 Network driver" ); |
478 | MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>" ); |
479 | MODULE_LICENSE("GPL" ); |
480 | |
481 | module_param_named(message, msg_enable, int, 0); |
482 | MODULE_PARM_DESC(message, "Message verbosity level (0=none, 31=all)" ); |
483 | MODULE_ALIAS("spi:ks8851" ); |
484 | |