This reverts commit
469fbe5da0229edcb42aa08bef8e10feaa37e6d7.
It isn't correct in places.
Reported-by: Gjorgji Rosikopulos <rosikopulos_gjorgji@projectara.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
unsigned long flags)
{
struct gb_connection *connection;
unsigned long flags)
{
struct gb_connection *connection;
- unsigned long irqflags;
int ret;
mutex_lock(&gb_connection_mutex);
int ret;
mutex_lock(&gb_connection_mutex);
gb_connection_init_name(connection);
gb_connection_init_name(connection);
- spin_lock_irqsave(&gb_connections_lock, irqflags);
+ spin_lock_irq(&gb_connections_lock);
list_add(&connection->hd_links, &hd->connections);
if (bundle)
list_add(&connection->hd_links, &hd->connections);
if (bundle)
else
INIT_LIST_HEAD(&connection->bundle_links);
else
INIT_LIST_HEAD(&connection->bundle_links);
- spin_unlock_irqrestore(&gb_connections_lock, irqflags);
+ spin_unlock_irq(&gb_connections_lock);
mutex_unlock(&gb_connection_mutex);
mutex_unlock(&gb_connection_mutex);
* DISCONNECTING.
*/
static void gb_connection_cancel_operations(struct gb_connection *connection,
* DISCONNECTING.
*/
static void gb_connection_cancel_operations(struct gb_connection *connection,
- int errno, unsigned long flags)
__must_hold(&connection->lock)
{
struct gb_operation *operation;
__must_hold(&connection->lock)
{
struct gb_operation *operation;
operation = list_last_entry(&connection->operations,
struct gb_operation, links);
gb_operation_get(operation);
operation = list_last_entry(&connection->operations,
struct gb_operation, links);
gb_operation_get(operation);
- spin_unlock_irqrestore(&connection->lock, flags);
+ spin_unlock_irq(&connection->lock);
if (gb_operation_is_incoming(operation))
gb_operation_cancel_incoming(operation, errno);
if (gb_operation_is_incoming(operation))
gb_operation_cancel_incoming(operation, errno);
gb_operation_put(operation);
gb_operation_put(operation);
- spin_lock_irqsave(&connection->lock, flags);
+ spin_lock_irq(&connection->lock);
*/
static void
gb_connection_flush_incoming_operations(struct gb_connection *connection,
*/
static void
gb_connection_flush_incoming_operations(struct gb_connection *connection,
- int errno, unsigned long flags)
__must_hold(&connection->lock)
{
struct gb_operation *operation;
__must_hold(&connection->lock)
{
struct gb_operation *operation;
- spin_unlock_irqrestore(&connection->lock, flags);
+ spin_unlock_irq(&connection->lock);
/* FIXME: flush, not cancel? */
gb_operation_cancel_incoming(operation, errno);
gb_operation_put(operation);
/* FIXME: flush, not cancel? */
gb_operation_cancel_incoming(operation, errno);
gb_operation_put(operation);
- spin_lock_irqsave(&connection->lock, flags);
+ spin_lock_irq(&connection->lock);
*/
static int _gb_connection_enable(struct gb_connection *connection, bool rx)
{
*/
static int _gb_connection_enable(struct gb_connection *connection, bool rx)
{
int ret;
/* Handle ENABLED_TX -> ENABLED transitions. */
int ret;
/* Handle ENABLED_TX -> ENABLED transitions. */
if (!(connection->handler && rx))
return 0;
if (!(connection->handler && rx))
return 0;
- spin_lock_irqsave(&connection->lock, flags);
+ spin_lock_irq(&connection->lock);
connection->state = GB_CONNECTION_STATE_ENABLED;
connection->state = GB_CONNECTION_STATE_ENABLED;
- spin_unlock_irqrestore(&connection->lock, flags);
+ spin_unlock_irq(&connection->lock);
if (ret)
goto err_svc_connection_destroy;
if (ret)
goto err_svc_connection_destroy;
- spin_lock_irqsave(&connection->lock, flags);
+ spin_lock_irq(&connection->lock);
if (connection->handler && rx)
connection->state = GB_CONNECTION_STATE_ENABLED;
else
connection->state = GB_CONNECTION_STATE_ENABLED_TX;
if (connection->handler && rx)
connection->state = GB_CONNECTION_STATE_ENABLED;
else
connection->state = GB_CONNECTION_STATE_ENABLED_TX;
- spin_unlock_irqrestore(&connection->lock, flags);
+ spin_unlock_irq(&connection->lock);
ret = gb_connection_control_connected(connection);
if (ret)
ret = gb_connection_control_connected(connection);
if (ret)
err_control_disconnecting:
gb_connection_control_disconnecting(connection);
err_control_disconnecting:
gb_connection_control_disconnecting(connection);
- spin_lock_irqsave(&connection->lock, flags);
+ spin_lock_irq(&connection->lock);
connection->state = GB_CONNECTION_STATE_DISCONNECTING;
connection->state = GB_CONNECTION_STATE_DISCONNECTING;
- gb_connection_cancel_operations(connection, -ESHUTDOWN, flags);
- spin_unlock_irqrestore(&connection->lock, flags);
+ gb_connection_cancel_operations(connection, -ESHUTDOWN);
+ spin_unlock_irq(&connection->lock);
/* Transmit queue should already be empty. */
gb_connection_hd_cport_flush(connection);
/* Transmit queue should already be empty. */
gb_connection_hd_cport_flush(connection);
void gb_connection_disable_rx(struct gb_connection *connection)
{
void gb_connection_disable_rx(struct gb_connection *connection)
{
mutex_lock(&connection->mutex);
mutex_lock(&connection->mutex);
- spin_lock_irqsave(&connection->lock, flags);
+ spin_lock_irq(&connection->lock);
if (connection->state != GB_CONNECTION_STATE_ENABLED) {
if (connection->state != GB_CONNECTION_STATE_ENABLED) {
- spin_unlock_irqrestore(&connection->lock, flags);
+ spin_unlock_irq(&connection->lock);
goto out_unlock;
}
connection->state = GB_CONNECTION_STATE_ENABLED_TX;
goto out_unlock;
}
connection->state = GB_CONNECTION_STATE_ENABLED_TX;
- gb_connection_flush_incoming_operations(connection, -ESHUTDOWN, flags);
- spin_unlock_irqrestore(&connection->lock, flags);
+ gb_connection_flush_incoming_operations(connection, -ESHUTDOWN);
+ spin_unlock_irq(&connection->lock);
trace_gb_connection_disable(connection);
trace_gb_connection_disable(connection);
void gb_connection_disable(struct gb_connection *connection)
{
void gb_connection_disable(struct gb_connection *connection)
{
mutex_lock(&connection->mutex);
if (connection->state == GB_CONNECTION_STATE_DISABLED)
mutex_lock(&connection->mutex);
if (connection->state == GB_CONNECTION_STATE_DISABLED)
gb_connection_control_disconnecting(connection);
gb_connection_control_disconnecting(connection);
- spin_lock_irqsave(&connection->lock, flags);
+ spin_lock_irq(&connection->lock);
connection->state = GB_CONNECTION_STATE_DISCONNECTING;
connection->state = GB_CONNECTION_STATE_DISCONNECTING;
- gb_connection_cancel_operations(connection, -ESHUTDOWN, flags);
- spin_unlock_irqrestore(&connection->lock, flags);
+ gb_connection_cancel_operations(connection, -ESHUTDOWN);
+ spin_unlock_irq(&connection->lock);
gb_connection_hd_cport_flush(connection);
gb_connection_hd_cport_flush(connection);
/* Disable a connection without communicating with the remote end. */
void gb_connection_disable_forced(struct gb_connection *connection)
{
/* Disable a connection without communicating with the remote end. */
void gb_connection_disable_forced(struct gb_connection *connection)
{
mutex_lock(&connection->mutex);
if (connection->state == GB_CONNECTION_STATE_DISABLED)
mutex_lock(&connection->mutex);
if (connection->state == GB_CONNECTION_STATE_DISABLED)
trace_gb_connection_disable(connection);
trace_gb_connection_disable(connection);
- spin_lock_irqsave(&connection->lock, flags);
+ spin_lock_irq(&connection->lock);
connection->state = GB_CONNECTION_STATE_DISABLED;
connection->state = GB_CONNECTION_STATE_DISABLED;
- gb_connection_cancel_operations(connection, -ESHUTDOWN, flags);
- spin_unlock_irqrestore(&connection->lock, flags);
+ gb_connection_cancel_operations(connection, -ESHUTDOWN);
+ spin_unlock_irq(&connection->lock);
gb_connection_hd_cport_flush(connection);
gb_connection_hd_cport_features_disable(connection);
gb_connection_hd_cport_flush(connection);
gb_connection_hd_cport_features_disable(connection);
/* Caller must have disabled the connection before destroying it. */
void gb_connection_destroy(struct gb_connection *connection)
{
/* Caller must have disabled the connection before destroying it. */
void gb_connection_destroy(struct gb_connection *connection)
{
mutex_lock(&gb_connection_mutex);
mutex_lock(&gb_connection_mutex);
- spin_lock_irqsave(&gb_connections_lock, flags);
+ spin_lock_irq(&gb_connections_lock);
list_del(&connection->bundle_links);
list_del(&connection->hd_links);
list_del(&connection->bundle_links);
list_del(&connection->hd_links);
- spin_unlock_irqrestore(&gb_connections_lock, flags);
+ spin_unlock_irq(&gb_connections_lock);
destroy_workqueue(connection->wq);
destroy_workqueue(connection->wq);
struct gb_host_device *hd = message->operation->connection->hd;
struct es2_ap_dev *es2 = hd_to_es2(hd);
struct urb *urb;
struct gb_host_device *hd = message->operation->connection->hd;
struct es2_ap_dev *es2 = hd_to_es2(hd);
struct urb *urb;
- spin_lock_irqsave(&es2->cport_out_urb_lock, flags);
+ spin_lock_irq(&es2->cport_out_urb_lock);
urb = message->hcpriv;
/* Prevent dynamically allocated urb from being deallocated. */
urb = message->hcpriv;
/* Prevent dynamically allocated urb from being deallocated. */
- spin_unlock_irqrestore(&es2->cport_out_urb_lock, flags);
+ spin_unlock_irq(&es2->cport_out_urb_lock);
usb_kill_urb(urb);
if (i < NUM_CPORT_OUT_URB) {
usb_kill_urb(urb);
if (i < NUM_CPORT_OUT_URB) {
- spin_lock_irqsave(&es2->cport_out_urb_lock, flags);
+ spin_lock_irq(&es2->cport_out_urb_lock);
es2->cport_out_urb_cancelled[i] = false;
es2->cport_out_urb_cancelled[i] = false;
- spin_unlock_irqrestore(&es2->cport_out_urb_lock, flags);
+ spin_unlock_irq(&es2->cport_out_urb_lock);
static int wait_serial_change(struct gb_tty *gb_tty, unsigned long arg)
{
int retval = 0;
static int wait_serial_change(struct gb_tty *gb_tty, unsigned long arg)
{
int retval = 0;
DECLARE_WAITQUEUE(wait, current);
struct async_icount old;
struct async_icount new;
DECLARE_WAITQUEUE(wait, current);
struct async_icount old;
struct async_icount new;
- spin_lock_irqsave(&gb_tty->read_lock, flags);
+ spin_lock_irq(&gb_tty->read_lock);
old = gb_tty->oldcount;
new = gb_tty->iocount;
gb_tty->oldcount = new;
old = gb_tty->oldcount;
new = gb_tty->iocount;
gb_tty->oldcount = new;
- spin_unlock_irqrestore(&gb_tty->read_lock, flags);
+ spin_unlock_irq(&gb_tty->read_lock);
if ((arg & TIOCM_DSR) && (old.dsr != new.dsr))
break;
if ((arg & TIOCM_DSR) && (old.dsr != new.dsr))
break;