// SPDX-License-Identifier: GPL-2.0-only /* drivers/net/ethernet/micrel/ks8851.c * * Copyright 2009 Simtec Electronics * http://www.simtec.co.uk/ * Ben Dooks <[email protected]> */ #define pr_fmt(fmt) … #include <linux/interrupt.h> #include <linux/module.h> #include <linux/kernel.h> #include <linux/netdevice.h> #include <linux/etherdevice.h> #include <linux/ethtool.h> #include <linux/cache.h> #include <linux/crc32.h> #include <linux/mii.h> #include <linux/gpio/consumer.h> #include <linux/regulator/consumer.h> #include <linux/of_mdio.h> #include <linux/of_net.h> #include "ks8851.h" /** * ks8851_lock - register access lock * @ks: The chip state * @flags: Spinlock flags * * Claim chip register access lock */ static void ks8851_lock(struct ks8851_net *ks, unsigned long *flags) { … } /** * ks8851_unlock - register access unlock * @ks: The chip state * @flags: Spinlock flags * * Release chip register access lock */ static void ks8851_unlock(struct ks8851_net *ks, unsigned long *flags) { … } /** * ks8851_wrreg16 - write 16bit register value to chip * @ks: The chip state * @reg: The register address * @val: The value to write * * Issue a write to put the value @val into the register specified in @reg. */ static void ks8851_wrreg16(struct ks8851_net *ks, unsigned int reg, unsigned int val) { … } /** * ks8851_rdreg16 - read 16 bit register from device * @ks: The chip information * @reg: The register address * * Read a 16bit register from the chip, returning the result */ static unsigned int ks8851_rdreg16(struct ks8851_net *ks, unsigned int reg) { … } /** * ks8851_soft_reset - issue one of the soft reset to the device * @ks: The device state. * @op: The bit(s) to set in the GRR * * Issue the relevant soft-reset command to the device's GRR register * specified by @op. * * Note, the delays are in there as a caution to ensure that the reset * has time to take effect and then complete. Since the datasheet does * not currently specify the exact sequence, we have chosen something * that seems to work with our device. */ static void ks8851_soft_reset(struct ks8851_net *ks, unsigned op) { … } /** * ks8851_set_powermode - set power mode of the device * @ks: The device state * @pwrmode: The power mode value to write to KS_PMECR. * * Change the power mode of the chip. */ static void ks8851_set_powermode(struct ks8851_net *ks, unsigned pwrmode) { … } /** * ks8851_write_mac_addr - write mac address to device registers * @dev: The network device * * Update the KS8851 MAC address registers from the address in @dev. * * This call assumes that the chip is not running, so there is no need to * shutdown the RXQ process whilst setting this. */ static int ks8851_write_mac_addr(struct net_device *dev) { … } /** * ks8851_read_mac_addr - read mac address from device registers * @dev: The network device * * Update our copy of the KS8851 MAC address from the registers of @dev. */ static void ks8851_read_mac_addr(struct net_device *dev) { … } /** * ks8851_init_mac - initialise the mac address * @ks: The device structure * @np: The device node pointer * * Get or create the initial mac address for the device and then set that * into the station address register. A mac address supplied in the device * tree takes precedence. Otherwise, if there is an EEPROM present, then * we try that. If no valid mac address is found we use eth_random_addr() * to create a new one. */ static void ks8851_init_mac(struct ks8851_net *ks, struct device_node *np) { … } /** * ks8851_dbg_dumpkkt - dump initial packet contents to debug * @ks: The device state * @rxpkt: The data for the received packet * * Dump the initial data from the packet to dev_dbg(). */ static void ks8851_dbg_dumpkkt(struct ks8851_net *ks, u8 *rxpkt) { … } /** * ks8851_rx_pkts - receive packets from the host * @ks: The device information. * @rxq: Queue of packets received in this function. * * This is called from the IRQ work queue when the system detects that there * are packets in the receive queue. Find out how many packets there are and * read them from the FIFO. */ static void ks8851_rx_pkts(struct ks8851_net *ks, struct sk_buff_head *rxq) { … } /** * ks8851_irq - IRQ handler for dealing with interrupt requests * @irq: IRQ number * @_ks: cookie * * This handler is invoked when the IRQ line asserts to find out what happened. * As we cannot allow ourselves to sleep in HARDIRQ context, this handler runs * in thread context. * * Read the interrupt status, work out what needs to be done and then clear * any of the interrupts that are not needed. */ static irqreturn_t ks8851_irq(int irq, void *_ks) { … } /** * ks8851_flush_tx_work - flush outstanding TX work * @ks: The device state */ static void ks8851_flush_tx_work(struct ks8851_net *ks) { … } /** * ks8851_net_open - open network device * @dev: The network device being opened. * * Called when the network device is marked active, such as a user executing * 'ifconfig up' on the device. */ static int ks8851_net_open(struct net_device *dev) { … } /** * ks8851_net_stop - close network device * @dev: The device being closed. * * Called to close down a network device which has been active. Cancell any * work, shutdown the RX and TX process and then place the chip into a low * power state whilst it is not being used. */ static int ks8851_net_stop(struct net_device *dev) { … } /** * ks8851_start_xmit - transmit packet * @skb: The buffer to transmit * @dev: The device used to transmit the packet. * * Called by the network layer to transmit the @skb. Queue the packet for * the device and schedule the necessary work to transmit the packet when * it is free. * * We do this to firstly avoid sleeping with the network device locked, * and secondly so we can round up more than one packet to transmit which * means we can try and avoid generating too many transmit done interrupts. */ static netdev_tx_t ks8851_start_xmit(struct sk_buff *skb, struct net_device *dev) { … } /** * ks8851_rxctrl_work - work handler to change rx mode * @work: The work structure this belongs to. * * Lock the device and issue the necessary changes to the receive mode from * the network device layer. This is done so that we can do this without * having to sleep whilst holding the network device lock. * * Since the recommendation from Micrel is that the RXQ is shutdown whilst the * receive parameters are programmed, we issue a write to disable the RXQ and * then wait for the interrupt handler to be triggered once the RXQ shutdown is * complete. The interrupt handler then writes the new values into the chip. */ static void ks8851_rxctrl_work(struct work_struct *work) { … } static void ks8851_set_rx_mode(struct net_device *dev) { … } static int ks8851_set_mac_address(struct net_device *dev, void *addr) { … } static int ks8851_net_ioctl(struct net_device *dev, struct ifreq *req, int cmd) { … } static const struct net_device_ops ks8851_netdev_ops = …; /* ethtool support */ static void ks8851_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *di) { … } static u32 ks8851_get_msglevel(struct net_device *dev) { … } static void ks8851_set_msglevel(struct net_device *dev, u32 to) { … } static int ks8851_get_link_ksettings(struct net_device *dev, struct ethtool_link_ksettings *cmd) { … } static int ks8851_set_link_ksettings(struct net_device *dev, const struct ethtool_link_ksettings *cmd) { … } static u32 ks8851_get_link(struct net_device *dev) { … } static int ks8851_nway_reset(struct net_device *dev) { … } /* EEPROM support */ static void ks8851_eeprom_regread(struct eeprom_93cx6 *ee) { … } static void ks8851_eeprom_regwrite(struct eeprom_93cx6 *ee) { … } /** * ks8851_eeprom_claim - claim device EEPROM and activate the interface * @ks: The network device state. * * Check for the presence of an EEPROM, and then activate software access * to the device. */ static int ks8851_eeprom_claim(struct ks8851_net *ks) { … } /** * ks8851_eeprom_release - release the EEPROM interface * @ks: The device state * * Release the software access to the device EEPROM */ static void ks8851_eeprom_release(struct ks8851_net *ks) { … } #define KS_EEPROM_MAGIC … static int ks8851_set_eeprom(struct net_device *dev, struct ethtool_eeprom *ee, u8 *data) { … } static int ks8851_get_eeprom(struct net_device *dev, struct ethtool_eeprom *ee, u8 *data) { … } static int ks8851_get_eeprom_len(struct net_device *dev) { … } static const struct ethtool_ops ks8851_ethtool_ops = …; /* MII interface controls */ /** * ks8851_phy_reg - convert MII register into a KS8851 register * @reg: MII register number. * * Return the KS8851 register number for the corresponding MII PHY register * if possible. Return zero if the MII register has no direct mapping to the * KS8851 register set. */ static int ks8851_phy_reg(int reg) { … } static int ks8851_phy_read_common(struct net_device *dev, int phy_addr, int reg) { … } /** * ks8851_phy_read - MII interface PHY register read. * @dev: The network device the PHY is on. * @phy_addr: Address of PHY (ignored as we only have one) * @reg: The register to read. * * This call reads data from the PHY register specified in @reg. Since the * device does not support all the MII registers, the non-existent values * are always returned as zero. * * We return zero for unsupported registers as the MII code does not check * the value returned for any error status, and simply returns it to the * caller. The mii-tool that the driver was tested with takes any -ve error * as real PHY capabilities, thus displaying incorrect data to the user. */ static int ks8851_phy_read(struct net_device *dev, int phy_addr, int reg) { … } static void ks8851_phy_write(struct net_device *dev, int phy, int reg, int value) { … } static int ks8851_mdio_read(struct mii_bus *bus, int phy_id, int reg) { … } static int ks8851_mdio_write(struct mii_bus *bus, int phy_id, int reg, u16 val) { … } /** * ks8851_read_selftest - read the selftest memory info. * @ks: The device state * * Read and check the TX/RX memory selftest information. */ static void ks8851_read_selftest(struct ks8851_net *ks) { … } /* driver bus management functions */ #ifdef CONFIG_PM_SLEEP int ks8851_suspend(struct device *dev) { … } EXPORT_SYMBOL_GPL(…); int ks8851_resume(struct device *dev) { … } EXPORT_SYMBOL_GPL(…); #endif static int ks8851_register_mdiobus(struct ks8851_net *ks, struct device *dev) { … } static void ks8851_unregister_mdiobus(struct ks8851_net *ks) { … } int ks8851_probe_common(struct net_device *netdev, struct device *dev, int msg_en) { … } EXPORT_SYMBOL_GPL(…); void ks8851_remove_common(struct device *dev) { … } EXPORT_SYMBOL_GPL(…); MODULE_DESCRIPTION(…) …; MODULE_AUTHOR(…) …; MODULE_LICENSE(…) …;
Codebase Browser
linux