/*
   * Thunderbolt Cactus Ridge driver - bus logic (NHI independent)
   *
   * Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
   */
  
  #include <linux/slab.h>
  #include <linux/errno.h>
  #include <linux/delay.h>
  
  #include "tb.h"

  #include "tb_regs.h"

  #include "tunnel_pci.h"

  
  /* enumeration & hot plug handling */
  
  
  static void tb_scan_port(struct tb_port *port);
  
  /**
   * tb_scan_switch() - scan for and initialize downstream switches
   */
  static void tb_scan_switch(struct tb_switch *sw)
  {
  	int i;
  	for (i = 1; i <= sw->config.max_port_number; i++)
  		tb_scan_port(&sw->ports[i]);
  }
  
  /**
   * tb_scan_port() - check for and initialize switches below port
   */
  static void tb_scan_port(struct tb_port *port)
  {
  	struct tb_switch *sw;
  	if (tb_is_upstream_port(port))
  		return;
  	if (port->config.type != TB_TYPE_PORT)
  		return;

  	if (port->dual_link_port && port->link_nr)
  		return; /*
  			 * Downstream switch is reachable through two ports.
  			 * Only scan on the primary port (link_nr == 0).
  			 */

  	if (tb_wait_for_port(port, false) <= 0)
  		return;
  	if (port->remote) {
  		tb_port_WARN(port, "port already has a remote!
  ");
  		return;
  	}
  	sw = tb_switch_alloc(port->sw->tb, tb_downstream_route(port));
  	if (!sw)
  		return;
  	port->remote = tb_upstream_port(sw);
  	tb_upstream_port(sw)->remote = port;
  	tb_scan_switch(sw);
  }

  /**
   * tb_free_invalid_tunnels() - destroy tunnels of devices that have gone away
   */
  static void tb_free_invalid_tunnels(struct tb *tb)
  {
  	struct tb_pci_tunnel *tunnel;
  	struct tb_pci_tunnel *n;
  	list_for_each_entry_safe(tunnel, n, &tb->tunnel_list, list)
  	{
  		if (tb_pci_is_invalid(tunnel)) {
  			tb_pci_deactivate(tunnel);
  			tb_pci_free(tunnel);
  		}
  	}
  }
  
  /**

   * tb_free_unplugged_children() - traverse hierarchy and free unplugged switches
   */
  static void tb_free_unplugged_children(struct tb_switch *sw)
  {
  	int i;
  	for (i = 1; i <= sw->config.max_port_number; i++) {
  		struct tb_port *port = &sw->ports[i];
  		if (tb_is_upstream_port(port))
  			continue;
  		if (!port->remote)
  			continue;
  		if (port->remote->sw->is_unplugged) {
  			tb_switch_free(port->remote->sw);
  			port->remote = NULL;
  		} else {
  			tb_free_unplugged_children(port->remote->sw);
  		}
  	}
  }
  
  
  /**

   * find_pci_up_port() - return the first PCIe up port on @sw or NULL
   */
  static struct tb_port *tb_find_pci_up_port(struct tb_switch *sw)
  {
  	int i;
  	for (i = 1; i <= sw->config.max_port_number; i++)
  		if (sw->ports[i].config.type == TB_TYPE_PCIE_UP)
  			return &sw->ports[i];
  	return NULL;
  }
  
  /**
   * find_unused_down_port() - return the first inactive PCIe down port on @sw
   */
  static struct tb_port *tb_find_unused_down_port(struct tb_switch *sw)
  {
  	int i;
  	int cap;
  	int res;
  	int data;
  	for (i = 1; i <= sw->config.max_port_number; i++) {
  		if (tb_is_upstream_port(&sw->ports[i]))
  			continue;
  		if (sw->ports[i].config.type != TB_TYPE_PCIE_DOWN)
  			continue;
  		cap = tb_find_cap(&sw->ports[i], TB_CFG_PORT, TB_CAP_PCIE);
  		if (cap <= 0)
  			continue;
  		res = tb_port_read(&sw->ports[i], &data, TB_CFG_PORT, cap, 1);
  		if (res < 0)
  			continue;
  		if (data & 0x80000000)
  			continue;
  		return &sw->ports[i];
  	}
  	return NULL;
  }
  
  /**
   * tb_activate_pcie_devices() - scan for and activate PCIe devices
   *
   * This method is somewhat ad hoc. For now it only supports one device
   * per port and only devices at depth 1.
   */
  static void tb_activate_pcie_devices(struct tb *tb)
  {
  	int i;
  	int cap;
  	u32 data;
  	struct tb_switch *sw;
  	struct tb_port *up_port;
  	struct tb_port *down_port;
  	struct tb_pci_tunnel *tunnel;
  	/* scan for pcie devices at depth 1*/
  	for (i = 1; i <= tb->root_switch->config.max_port_number; i++) {
  		if (tb_is_upstream_port(&tb->root_switch->ports[i]))
  			continue;
  		if (tb->root_switch->ports[i].config.type != TB_TYPE_PORT)
  			continue;
  		if (!tb->root_switch->ports[i].remote)
  			continue;
  		sw = tb->root_switch->ports[i].remote->sw;
  		up_port = tb_find_pci_up_port(sw);
  		if (!up_port) {
  			tb_sw_info(sw, "no PCIe devices found, aborting
  ");
  			continue;
  		}
  
  		/* check whether port is already activated */
  		cap = tb_find_cap(up_port, TB_CFG_PORT, TB_CAP_PCIE);
  		if (cap <= 0)
  			continue;
  		if (tb_port_read(up_port, &data, TB_CFG_PORT, cap, 1))
  			continue;
  		if (data & 0x80000000) {
  			tb_port_info(up_port,
  				     "PCIe port already activated, aborting
  ");
  			continue;
  		}
  
  		down_port = tb_find_unused_down_port(tb->root_switch);
  		if (!down_port) {
  			tb_port_info(up_port,
  				     "All PCIe down ports are occupied, aborting
  ");
  			continue;
  		}
  		tunnel = tb_pci_alloc(tb, up_port, down_port);
  		if (!tunnel) {
  			tb_port_info(up_port,
  				     "PCIe tunnel allocation failed, aborting
  ");
  			continue;
  		}
  
  		if (tb_pci_activate(tunnel)) {
  			tb_port_info(up_port,
  				     "PCIe tunnel activation failed, aborting
  ");
  			tb_pci_free(tunnel);
  		}
  
  	}
  }

  /* hotplug handling */
  
  struct tb_hotplug_event {
  	struct work_struct work;
  	struct tb *tb;
  	u64 route;
  	u8 port;
  	bool unplug;
  };
  
  /**
   * tb_handle_hotplug() - handle hotplug event
   *
   * Executes on tb->wq.
   */
  static void tb_handle_hotplug(struct work_struct *work)
  {
  	struct tb_hotplug_event *ev = container_of(work, typeof(*ev), work);
  	struct tb *tb = ev->tb;

  	struct tb_switch *sw;
  	struct tb_port *port;

  	mutex_lock(&tb->lock);
  	if (!tb->hotplug_active)
  		goto out; /* during init, suspend or shutdown */

  	sw = get_switch_at_route(tb->root_switch, ev->route);
  	if (!sw) {
  		tb_warn(tb,
  			"hotplug event from non existent switch %llx:%x (unplug: %d)
  ",
  			ev->route, ev->port, ev->unplug);
  		goto out;
  	}
  	if (ev->port > sw->config.max_port_number) {
  		tb_warn(tb,
  			"hotplug event from non existent port %llx:%x (unplug: %d)
  ",
  			ev->route, ev->port, ev->unplug);
  		goto out;
  	}
  	port = &sw->ports[ev->port];
  	if (tb_is_upstream_port(port)) {
  		tb_warn(tb,
  			"hotplug event for upstream port %llx:%x (unplug: %d)
  ",
  			ev->route, ev->port, ev->unplug);
  		goto out;
  	}
  	if (ev->unplug) {
  		if (port->remote) {
  			tb_port_info(port, "unplugged
  ");

  			tb_sw_set_unplugged(port->remote->sw);

  			tb_free_invalid_tunnels(tb);

  			tb_switch_free(port->remote->sw);
  			port->remote = NULL;
  		} else {
  			tb_port_info(port,
  				     "got unplug event for disconnected port, ignoring
  ");
  		}
  	} else if (port->remote) {
  		tb_port_info(port,
  			     "got plug event for connected port, ignoring
  ");
  	} else {
  		tb_port_info(port, "hotplug: scanning
  ");
  		tb_scan_port(port);
  		if (!port->remote) {
  			tb_port_info(port, "hotplug: no switch found
  ");
  		} else if (port->remote->sw->config.depth > 1) {
  			tb_sw_warn(port->remote->sw,
  				   "hotplug: chaining not supported
  ");

  		} else {
  			tb_sw_info(port->remote->sw,
  				   "hotplug: activating pcie devices
  ");
  			tb_activate_pcie_devices(tb);

  		}
  	}

  out:
  	mutex_unlock(&tb->lock);
  	kfree(ev);
  }
  
  /**
   * tb_schedule_hotplug_handler() - callback function for the control channel
   *
   * Delegates to tb_handle_hotplug.
   */
  static void tb_schedule_hotplug_handler(void *data, u64 route, u8 port,
  					bool unplug)
  {
  	struct tb *tb = data;
  	struct tb_hotplug_event *ev = kmalloc(sizeof(*ev), GFP_KERNEL);
  	if (!ev)
  		return;
  	INIT_WORK(&ev->work, tb_handle_hotplug);
  	ev->tb = tb;
  	ev->route = route;
  	ev->port = port;
  	ev->unplug = unplug;
  	queue_work(tb->wq, &ev->work);
  }
  
  /**
   * thunderbolt_shutdown_and_free() - shutdown everything
   *
   * Free all switches and the config channel.
   *
   * Used in the error path of thunderbolt_alloc_and_start.
   */
  void thunderbolt_shutdown_and_free(struct tb *tb)
  {

  	struct tb_pci_tunnel *tunnel;
  	struct tb_pci_tunnel *n;

  	mutex_lock(&tb->lock);

  	/* tunnels are only present after everything has been initialized */
  	list_for_each_entry_safe(tunnel, n, &tb->tunnel_list, list) {
  		tb_pci_deactivate(tunnel);
  		tb_pci_free(tunnel);
  	}

  	if (tb->root_switch)
  		tb_switch_free(tb->root_switch);
  	tb->root_switch = NULL;

  	if (tb->ctl) {
  		tb_ctl_stop(tb->ctl);
  		tb_ctl_free(tb->ctl);
  	}
  	tb->ctl = NULL;
  	tb->hotplug_active = false; /* signal tb_handle_hotplug to quit */
  
  	/* allow tb_handle_hotplug to acquire the lock */
  	mutex_unlock(&tb->lock);
  	if (tb->wq) {
  		flush_workqueue(tb->wq);
  		destroy_workqueue(tb->wq);
  		tb->wq = NULL;
  	}
  	mutex_destroy(&tb->lock);
  	kfree(tb);
  }
  
  /**
   * thunderbolt_alloc_and_start() - setup the thunderbolt bus
   *
   * Allocates a tb_cfg control channel, initializes the root switch, enables
   * plug events and activates pci devices.
   *
   * Return: Returns NULL on error.
   */
  struct tb *thunderbolt_alloc_and_start(struct tb_nhi *nhi)
  {
  	struct tb *tb;

  	BUILD_BUG_ON(sizeof(struct tb_regs_switch_header) != 5 * 4);
  	BUILD_BUG_ON(sizeof(struct tb_regs_port_header) != 8 * 4);
  	BUILD_BUG_ON(sizeof(struct tb_regs_hop) != 2 * 4);

  	tb = kzalloc(sizeof(*tb), GFP_KERNEL);
  	if (!tb)
  		return NULL;
  
  	tb->nhi = nhi;
  	mutex_init(&tb->lock);
  	mutex_lock(&tb->lock);

  	INIT_LIST_HEAD(&tb->tunnel_list);

  
  	tb->wq = alloc_ordered_workqueue("thunderbolt", 0);
  	if (!tb->wq)
  		goto err_locked;
  
  	tb->ctl = tb_ctl_alloc(tb->nhi, tb_schedule_hotplug_handler, tb);
  	if (!tb->ctl)
  		goto err_locked;
  	/*
  	 * tb_schedule_hotplug_handler may be called as soon as the config
  	 * channel is started. Thats why we have to hold the lock here.
  	 */
  	tb_ctl_start(tb->ctl);

  	tb->root_switch = tb_switch_alloc(tb, 0);
  	if (!tb->root_switch)
  		goto err_locked;

  	/* Full scan to discover devices added before the driver was loaded. */
  	tb_scan_switch(tb->root_switch);

  	tb_activate_pcie_devices(tb);

  	/* Allow tb_handle_hotplug to progress events */
  	tb->hotplug_active = true;
  	mutex_unlock(&tb->lock);
  	return tb;
  
  err_locked:
  	mutex_unlock(&tb->lock);
  	thunderbolt_shutdown_and_free(tb);
  	return NULL;
  }

  void thunderbolt_suspend(struct tb *tb)
  {
  	tb_info(tb, "suspending...
  ");
  	mutex_lock(&tb->lock);
  	tb_switch_suspend(tb->root_switch);
  	tb_ctl_stop(tb->ctl);
  	tb->hotplug_active = false; /* signal tb_handle_hotplug to quit */
  	mutex_unlock(&tb->lock);
  	tb_info(tb, "suspend finished
  ");
  }
  
  void thunderbolt_resume(struct tb *tb)
  {
  	struct tb_pci_tunnel *tunnel, *n;
  	tb_info(tb, "resuming...
  ");
  	mutex_lock(&tb->lock);
  	tb_ctl_start(tb->ctl);
  
  	/* remove any pci devices the firmware might have setup */
  	tb_switch_reset(tb, 0);
  
  	tb_switch_resume(tb->root_switch);
  	tb_free_invalid_tunnels(tb);
  	tb_free_unplugged_children(tb->root_switch);
  	list_for_each_entry_safe(tunnel, n, &tb->tunnel_list, list)
  		tb_pci_restart(tunnel);
  	if (!list_empty(&tb->tunnel_list)) {
  		/*
  		 * the pcie links need some time to get going.
  		 * 100ms works for me...
  		 */
  		tb_info(tb, "tunnels restarted, sleeping for 100ms
  ");
  		msleep(100);
  	}
  	 /* Allow tb_handle_hotplug to progress events */
  	tb->hotplug_active = true;
  	mutex_unlock(&tb->lock);
  	tb_info(tb, "resume finished
  ");
  }