/**
* fm10k_open - Called when a network interface is made active
* @netdev: network interface device structure
*
* Returns 0 on success, negative value on failure
*
* The open entry point is called when a network interface is made
* active by the system (IFF_UP). At this point all resources needed
* for transmit and receive operations are allocated, the interrupt
* handler is registered with the OS, the watchdog timer is started,
* and the stack is notified that the interface is ready.
**/
int fm10k_open(struct net_device *netdev)
{
struct fm10k_intfc *interface = netdev_priv(netdev);
int err;
/* allocate transmit descriptors */
err = fm10k_setup_all_tx_resources(interface);
if (err)
goto err_setup_tx;
/* allocate receive descriptors */
err = fm10k_setup_all_rx_resources(interface);
if (err)
goto err_setup_rx;
/* allocate interrupt resources */
err = fm10k_qv_request_irq(interface);
if (err)
goto err_req_irq;
/* setup GLORT assignment for this port */
fm10k_request_glort_range(interface);
/* Notify the stack of the actual queue counts */
err = netif_set_real_num_tx_queues(netdev,
interface->num_tx_queues);
if (err)
goto err_set_queues;
err = netif_set_real_num_rx_queues(netdev,
interface->num_rx_queues);
if (err)
goto err_set_queues;
#if IS_ENABLED(CONFIG_VXLAN)
/* update VXLAN port configuration */
vxlan_get_rx_port(netdev);
#endif
fm10k_up(interface);
return 0;
err_set_queues:
fm10k_qv_free_irq(interface);
err_req_irq:
fm10k_free_all_rx_resources(interface);
err_setup_rx:
fm10k_free_all_tx_resources(interface);
err_setup_tx:
return err;
}
/**
* fm10k_open - Called when a network interface is made active
* @netdev: network interface device structure
*
* Returns 0 on success, negative value on failure
*
* The open entry point is called when a network interface is made
* active by the system (IFF_UP). At this point all resources needed
* for transmit and receive operations are allocated, the interrupt
* handler is registered with the OS, the watchdog timer is started,
* and the stack is notified that the interface is ready.
**/
int fm10k_open(struct net_device *netdev)
{
struct fm10k_intfc *interface = netdev_priv(netdev);
int err;
/* allocate transmit descriptors */
err = fm10k_setup_all_tx_resources(interface);
if (err)
goto err_setup_tx;
/* allocate receive descriptors */
err = fm10k_setup_all_rx_resources(interface);
if (err)
goto err_setup_rx;
/* allocate interrupt resources */
err = fm10k_qv_request_irq(interface);
if (err)
goto err_req_irq;
/* setup GLORT assignment for this port */
fm10k_request_glort_range(interface);
/* Notify the stack of the actual queue counts */
err = netif_set_real_num_tx_queues(netdev,
interface->num_tx_queues);
if (err)
goto err_set_queues;
err = netif_set_real_num_rx_queues(netdev,
interface->num_rx_queues);
if (err)
goto err_set_queues;
udp_tunnel_get_rx_info(netdev);
fm10k_up(interface);
return 0;
err_set_queues:
fm10k_qv_free_irq(interface);
err_req_irq:
fm10k_free_all_rx_resources(interface);
err_setup_rx:
fm10k_free_all_tx_resources(interface);
err_setup_tx:
return err;
}
static int fm10k_set_ringparam(struct net_device *netdev,
struct ethtool_ringparam *ring)
{
struct fm10k_intfc *interface = netdev_priv(netdev);
struct fm10k_ring *temp_ring;
int i, err = 0;
u32 new_rx_count, new_tx_count;
if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
return -EINVAL;
new_tx_count = clamp_t(u32, ring->tx_pending,
FM10K_MIN_TXD, FM10K_MAX_TXD);
new_tx_count = ALIGN(new_tx_count, FM10K_REQ_TX_DESCRIPTOR_MULTIPLE);
new_rx_count = clamp_t(u32, ring->rx_pending,
FM10K_MIN_RXD, FM10K_MAX_RXD);
new_rx_count = ALIGN(new_rx_count, FM10K_REQ_RX_DESCRIPTOR_MULTIPLE);
if ((new_tx_count == interface->tx_ring_count) &&
(new_rx_count == interface->rx_ring_count)) {
/* nothing to do */
return 0;
}
while (test_and_set_bit(__FM10K_RESETTING, &interface->state))
usleep_range(1000, 2000);
if (!netif_running(interface->netdev)) {
for (i = 0; i < interface->num_tx_queues; i++)
interface->tx_ring[i]->count = new_tx_count;
for (i = 0; i < interface->num_rx_queues; i++)
interface->rx_ring[i]->count = new_rx_count;
interface->tx_ring_count = new_tx_count;
interface->rx_ring_count = new_rx_count;
goto clear_reset;
}
/* allocate temporary buffer to store rings in */
i = max_t(int, interface->num_tx_queues, interface->num_rx_queues);
temp_ring = vmalloc(i * sizeof(struct fm10k_ring));
if (!temp_ring) {
err = -ENOMEM;
goto clear_reset;
}
fm10k_down(interface);
/* Setup new Tx resources and free the old Tx resources in that order.
* We can then assign the new resources to the rings via a memcpy.
* The advantage to this approach is that we are guaranteed to still
* have resources even in the case of an allocation failure.
*/
if (new_tx_count != interface->tx_ring_count) {
for (i = 0; i < interface->num_tx_queues; i++) {
memcpy(&temp_ring[i], interface->tx_ring[i],
sizeof(struct fm10k_ring));
temp_ring[i].count = new_tx_count;
err = fm10k_setup_tx_resources(&temp_ring[i]);
if (err) {
while (i) {
i--;
fm10k_free_tx_resources(&temp_ring[i]);
}
goto err_setup;
}
}
for (i = 0; i < interface->num_tx_queues; i++) {
fm10k_free_tx_resources(interface->tx_ring[i]);
memcpy(interface->tx_ring[i], &temp_ring[i],
sizeof(struct fm10k_ring));
}
interface->tx_ring_count = new_tx_count;
}
/* Repeat the process for the Rx rings if needed */
if (new_rx_count != interface->rx_ring_count) {
for (i = 0; i < interface->num_rx_queues; i++) {
memcpy(&temp_ring[i], interface->rx_ring[i],
sizeof(struct fm10k_ring));
temp_ring[i].count = new_rx_count;
err = fm10k_setup_rx_resources(&temp_ring[i]);
if (err) {
while (i) {
i--;
fm10k_free_rx_resources(&temp_ring[i]);
}
goto err_setup;
}
}
for (i = 0; i < interface->num_rx_queues; i++) {
fm10k_free_rx_resources(interface->rx_ring[i]);
memcpy(interface->rx_ring[i], &temp_ring[i],
sizeof(struct fm10k_ring));
}
interface->rx_ring_count = new_rx_count;
}
err_setup:
fm10k_up(interface);
vfree(temp_ring);
clear_reset:
clear_bit(__FM10K_RESETTING, &interface->state);
return err;
}
