Merge branch 'master' of git://github.com/libopencm3/libopencm3 into upstream-merge

lib/usb/usb.c

@@ -21,8 +21,6 @@
 #include <libopencm3/usb/usbd.h>
 #include "usb_private.h"
 
-struct _usbd_device _usbd_device;
-
 u8 usbd_control_buffer[128] __attribute__((weak));
 
 /**
@@ -43,106 +41,112 @@ u8 usbd_control_buffer[128] __attribute__((weak));
  * @param strings TODO
  * @return Zero on success (currently cannot fail).
  */
-int usbd_init(const usbd_driver *driver,
-	      const struct usb_device_descriptor *dev,
-	      const struct usb_config_descriptor *conf,
-	      const char **strings, int num_strings)
+usbd_device *usbd_init(const usbd_driver *driver,
+	      	       const struct usb_device_descriptor *dev,
+	      	       const struct usb_config_descriptor *conf,
+		       const char **strings, int num_strings)
 {
-	_usbd_device.driver = driver;
-	_usbd_device.desc = dev;
-	_usbd_device.config = conf;
-	_usbd_device.strings = strings;
-	_usbd_device.num_strings = num_strings;
-	_usbd_device.ctrl_buf = usbd_control_buffer;
-	_usbd_device.ctrl_buf_len = sizeof(usbd_control_buffer);
+	usbd_device *usbd_dev;
 
-	_usbd_hw_init();
+	usbd_dev = driver->init();
 
-	_usbd_device.user_callback_ctr[0][USB_TRANSACTION_SETUP] =
+	usbd_dev->driver = driver;
+	usbd_dev->desc = dev;
+	usbd_dev->config = conf;
+	usbd_dev->strings = strings;
+	usbd_dev->num_strings = num_strings;
+	usbd_dev->ctrl_buf = usbd_control_buffer;
+	usbd_dev->ctrl_buf_len = sizeof(usbd_control_buffer);
+
+	usbd_dev->user_callback_ctr[0][USB_TRANSACTION_SETUP] =
 	    _usbd_control_setup;
-	_usbd_device.user_callback_ctr[0][USB_TRANSACTION_OUT] =
+	usbd_dev->user_callback_ctr[0][USB_TRANSACTION_OUT] =
 	    _usbd_control_out;
-	_usbd_device.user_callback_ctr[0][USB_TRANSACTION_IN] =
+	usbd_dev->user_callback_ctr[0][USB_TRANSACTION_IN] =
 	    _usbd_control_in;
 
-	return 0;
+	return usbd_dev;
 }
 
-void usbd_register_reset_callback(void (*callback)(void))
+void usbd_register_reset_callback(usbd_device *usbd_dev, void (*callback)(void))
 {
-	_usbd_device.user_callback_reset = callback;
+	usbd_dev->user_callback_reset = callback;
 }
 
-void usbd_register_suspend_callback(void (*callback)(void))
+void usbd_register_suspend_callback(usbd_device *usbd_dev,
+				    void (*callback)(void))
 {
-	_usbd_device.user_callback_suspend = callback;
+	usbd_dev->user_callback_suspend = callback;
 }
 
-void usbd_register_resume_callback(void (*callback)(void))
+void usbd_register_resume_callback(usbd_device *usbd_dev,
+				   void (*callback)(void))
 {
-	_usbd_device.user_callback_resume = callback;
+	usbd_dev->user_callback_resume = callback;
 }
 
-void usbd_register_sof_callback(void (*callback)(void))
+void usbd_register_sof_callback(usbd_device *usbd_dev, void (*callback)(void))
 {
-	_usbd_device.user_callback_sof = callback;
+	usbd_dev->user_callback_sof = callback;
 }
 
-void usbd_set_control_buffer_size(u16 size)
+void usbd_set_control_buffer_size(usbd_device *usbd_dev, u16 size)
 {
-	_usbd_device.ctrl_buf_len = size;
+	usbd_dev->ctrl_buf_len = size;
 }
 
-void _usbd_reset(void)
+void _usbd_reset(usbd_device *usbd_dev)
 {
-	_usbd_device.current_address = 0;
-	_usbd_device.current_config = 0;
-	usbd_ep_setup(0, USB_ENDPOINT_ATTR_CONTROL, 64, NULL);
-	_usbd_hw_set_address(0);
+	usbd_dev->current_address = 0;
+	usbd_dev->current_config = 0;
+	usbd_ep_setup(usbd_dev, 0, USB_ENDPOINT_ATTR_CONTROL, 64, NULL);
+	usbd_dev->driver->set_address(usbd_dev, 0);
 
-	if (_usbd_device.user_callback_reset)
-		_usbd_device.user_callback_reset();
+	if (usbd_dev->user_callback_reset)
+		usbd_dev->user_callback_reset();
 }
 
 /* Functions to wrap the low-level driver */
-void usbd_poll(void)
+void usbd_poll(usbd_device *usbd_dev)
 {
-	_usbd_device.driver->poll();
+	usbd_dev->driver->poll(usbd_dev);
 }
 
-void usbd_disconnect(bool disconnected)
+void usbd_disconnect(usbd_device *usbd_dev, bool disconnected)
 {
 	/* not all drivers support disconnection */
-	if (_usbd_device.driver->disconnect)
-		_usbd_device.driver->disconnect(disconnected);
+	if (usbd_dev->driver->disconnect)
+		usbd_dev->driver->disconnect(usbd_dev, disconnected);
 }
 
-void usbd_ep_setup(u8 addr, u8 type, u16 max_size, void (*callback)(u8 ep))
+void usbd_ep_setup(usbd_device *usbd_dev, u8 addr, u8 type, u16 max_size,
+		   void (*callback)(usbd_device *usbd_dev, u8 ep))
 {
-	_usbd_device.driver->ep_setup(addr, type, max_size, callback);
+	usbd_dev->driver->ep_setup(usbd_dev, addr, type, max_size, callback);
 }
 
-u16 usbd_ep_write_packet(u8 addr, const void *buf, u16 len)
+u16 usbd_ep_write_packet(usbd_device *usbd_dev, u8 addr,
+			 const void *buf, u16 len)
 {
-	return _usbd_device.driver->ep_write_packet(addr, buf, len);
+	return usbd_dev->driver->ep_write_packet(usbd_dev, addr, buf, len);
 }
 
-u16 usbd_ep_read_packet(u8 addr, void *buf, u16 len)
+u16 usbd_ep_read_packet(usbd_device *usbd_dev, u8 addr, void *buf, u16 len)
 {
-	return _usbd_device.driver->ep_read_packet(addr, buf, len);
+	return usbd_dev->driver->ep_read_packet(usbd_dev, addr, buf, len);
 }
 
-void usbd_ep_stall_set(u8 addr, u8 stall)
+void usbd_ep_stall_set(usbd_device *usbd_dev, u8 addr, u8 stall)
 {
-	_usbd_device.driver->ep_stall_set(addr, stall);
+	usbd_dev->driver->ep_stall_set(usbd_dev, addr, stall);
 }
 
-u8 usbd_ep_stall_get(u8 addr)
+u8 usbd_ep_stall_get(usbd_device *usbd_dev, u8 addr)
 {
-	return _usbd_device.driver->ep_stall_get(addr);
+	return usbd_dev->driver->ep_stall_get(usbd_dev, addr);
 }
 
-void usbd_ep_nak_set(u8 addr, u8 nak)
+void usbd_ep_nak_set(usbd_device *usbd_dev, u8 addr, u8 nak)
 {
-	_usbd_device.driver->ep_nak_set(addr, nak);
+	usbd_dev->driver->ep_nak_set(usbd_dev, addr, nak);
 }