static int acm_suspend(struct usb_interface *intf, pm_message_t message)
{
struct acm *acm = usb_get_intfdata(intf);
int cnt;
if (message.event & PM_EVENT_AUTO) {
int b;
spin_lock_irq(&acm->write_lock);
b = acm->transmitting;
spin_unlock_irq(&acm->write_lock);
if (b)
return -EBUSY;
}
spin_lock_irq(&acm->read_lock);
spin_lock(&acm->write_lock);
cnt = acm->susp_count++;
spin_unlock(&acm->write_lock);
spin_unlock_irq(&acm->read_lock);
if (cnt)
return 0;
/*
we treat opened interfaces differently,
we must guard against open
*/
mutex_lock(&acm->mutex);
if (acm->port.count)
stop_data_traffic(acm);
mutex_unlock(&acm->mutex);
return 0;
}
static int acm_suspend(struct usb_interface *intf, pm_message_t message)
{
struct acm *acm = usb_get_intfdata(intf);
int cnt;
spin_lock_irq(&acm->read_lock);
spin_lock(&acm->write_lock);
if (PMSG_IS_AUTO(message)) {
if (acm->transmitting) {
spin_unlock(&acm->write_lock);
spin_unlock_irq(&acm->read_lock);
return -EBUSY;
}
}
cnt = acm->susp_count++;
spin_unlock(&acm->write_lock);
spin_unlock_irq(&acm->read_lock);
if (cnt)
return 0;
stop_data_traffic(acm);
return 0;
}
static void modem_close(struct usb_serial_port *port)
{
struct modem_port *modem_port_ptr = usb_get_serial_data(port->serial);
if (!modem_port_ptr) {
dev_err(&port->dev,
"%s: null modem port pointer.\n",
__func__);
return;
}
if (cdma_modem_debug)
dev_info(&port->dev, "%s: Enter. Close Port %d\n",
__func__, modem_port_ptr->number);
modem_port_ptr->port_closing = 1;
/* For the data modem port, the pm interface needs to be get here
* and will be put back at serial_close() of usb-serial.c
*/
if (modem_port_ptr->number == MODEM_INTERFACE_NUM)
usb_autopm_get_interface(
modem_port_ptr->port->serial->interface);
stop_data_traffic(modem_port_ptr);
cancel_work_sync(&modem_port_ptr->wake_and_write);
modem_port_ptr->port = 0;
modem_port_ptr->modem_status = 0;
if (modem_port_ptr->delayed_wb)
modem_port_ptr->delayed_wb->use = 0;
if (cdma_modem_debug)
dev_info(&port->dev, "%s: Exit.\n", __func__);
}
static int acm_suspend(struct usb_interface *intf, pm_message_t message)
{
struct acm *acm = usb_get_intfdata(intf);
int cnt;
if (PMSG_IS_AUTO(message)) {
int b;
spin_lock_irq(&acm->write_lock);
b = acm->transmitting;
spin_unlock_irq(&acm->write_lock);
if (b)
return -EBUSY;
}
spin_lock_irq(&acm->read_lock);
spin_lock(&acm->write_lock);
cnt = acm->susp_count++;
spin_unlock(&acm->write_lock);
spin_unlock_irq(&acm->read_lock);
if (cnt)
return 0;
if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags))
stop_data_traffic(acm);
return 0;
}
static void acm_disconnect(struct usb_interface *intf)
{
struct acm *acm = usb_get_intfdata(intf);
struct usb_device *usb_dev = interface_to_usbdev(intf);
struct tty_struct *tty;
struct urb *res;
u32 project_info = tegra3_get_project_id();
/* sibling interface is already cleaning up */
if (!acm)
return;
mutex_lock(&open_mutex);
if (acm->country_codes) {
device_remove_file(&acm->control->dev,
&dev_attr_wCountryCodes);
device_remove_file(&acm->control->dev,
&dev_attr_iCountryCodeRelDate);
}
device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
acm->dev = NULL;
usb_set_intfdata(acm->control, NULL);
usb_set_intfdata(acm->data, NULL);
stop_data_traffic(acm);
/* decrement ref count of anchored urbs */
while ((res = usb_get_from_anchor(&acm->deferred)))
usb_put_urb(res);
acm_write_buffers_free(acm);
usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
acm->ctrl_dma);
acm_read_buffers_free(acm);
if (!acm->combined_interfaces)
usb_driver_release_interface(&acm_driver, intf == acm->control ?
acm->data : acm->control);
if (acm->port.count == 0) {
acm_tty_unregister(acm);
mutex_unlock(&open_mutex);
return;
}
mutex_unlock(&open_mutex);
tty = tty_port_tty_get(&acm->port);
if (tty) {
tty_hangup(tty);
tty_kref_put(tty);
}
if (project_info == TEGRA3_PROJECT_TF201) {
if(gps_dongle_flag == true) {
dev_info(&usb_dev->dev, "ublox - GPS Receiver Dongle unplug.\n");
gps_dongle_flag = false;
}
}
}
static void acm_disconnect(struct usb_interface *intf)
{
struct acm *acm = usb_get_intfdata(intf);
struct usb_device *usb_dev = interface_to_usbdev(intf);
struct tty_struct *tty;
int i;
dev_dbg(&intf->dev, "%s\n", __func__);
/* sibling interface is already cleaning up */
if (!acm)
return;
mutex_lock(&acm->mutex);
acm->disconnected = true;
if (acm->country_codes) {
device_remove_file(&acm->control->dev,
&dev_attr_wCountryCodes);
device_remove_file(&acm->control->dev,
&dev_attr_iCountryCodeRelDate);
kfree(acm->country_codes);
}
device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
usb_set_intfdata(acm->control, NULL);
usb_set_intfdata(acm->data, NULL);
mutex_unlock(&acm->mutex);
tty = tty_port_tty_get(&acm->port);
if (tty) {
tty_vhangup(tty);
tty_kref_put(tty);
}
stop_data_traffic(acm);
tty_unregister_device(acm_tty_driver, acm->minor);
usb_free_urb(acm->ctrlurb);
for (i = 0; i < ACM_NW; i++)
usb_free_urb(acm->wb[i].urb);
for (i = 0; i < acm->rx_buflimit; i++)
usb_free_urb(acm->read_urbs[i]);
acm_write_buffers_free(acm);
usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
acm_read_buffers_free(acm);
if (!acm->combined_interfaces)
usb_driver_release_interface(&acm_driver, intf == acm->control ?
acm->data : acm->control);
tty_port_put(&acm->port);
}
static void acm_disconnect(struct usb_interface *intf)
{
struct acm *acm = usb_get_intfdata(intf);
struct usb_device *usb_dev = interface_to_usbdev(intf);
int i;
if (!acm || !acm->dev) {
dbg("disconnect on nonexisting interface");
return;
}
mutex_lock(&open_mutex);
if (!usb_get_intfdata(intf)) {
mutex_unlock(&open_mutex);
return;
}
if (acm->country_codes){
device_remove_file(&acm->control->dev,
&dev_attr_wCountryCodes);
device_remove_file(&acm->control->dev,
&dev_attr_iCountryCodeRelDate);
}
device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
acm->dev = NULL;
usb_set_intfdata(acm->control, NULL);
usb_set_intfdata(acm->data, NULL);
stop_data_traffic(acm);
acm_write_buffers_free(acm);
usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
for (i = 0; i < acm->rx_buflimit; i++)
usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
usb_driver_release_interface(&acm_driver, intf == acm->control ? acm->data : intf);
if (!acm->used) {
acm_tty_unregister(acm);
mutex_unlock(&open_mutex);
return;
}
mutex_unlock(&open_mutex);
if (acm->tty)
tty_hangup(acm->tty);
}
static void acm_disconnect(struct usb_interface *intf)
{
struct acm *acm = usb_get_intfdata(intf);
struct usb_device *usb_dev = interface_to_usbdev(intf);
struct tty_struct *tty;
/* sibling interface is already cleaning up */
if (!acm)
return;
mutex_lock(&open_mutex);
if (acm->country_codes) {
device_remove_file(&acm->control->dev,
&dev_attr_wCountryCodes);
device_remove_file(&acm->control->dev,
&dev_attr_iCountryCodeRelDate);
}
device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
acm->dev = NULL;
usb_set_intfdata(acm->control, NULL);
usb_set_intfdata(acm->data, NULL);
stop_data_traffic(acm);
usb_kill_anchored_urbs(&acm->deferred);
acm_write_buffers_free(acm);
usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
acm->ctrl_dma);
acm_read_buffers_free(acm);
if (!acm->combined_interfaces)
usb_driver_release_interface(&acm_driver, intf == acm->control ?
acm->data : acm->control);
if (acm->port.count == 0) {
acm_tty_unregister(acm);
mutex_unlock(&open_mutex);
return;
}
mutex_unlock(&open_mutex);
tty = tty_port_tty_get(&acm->port);
if (tty) {
tty_hangup(tty);
tty_kref_put(tty);
}
}
static int acm_suspend(struct usb_interface *intf, pm_message_t message)
{
struct acm *acm = usb_get_intfdata(intf);
if (acm->susp_count++)
return 0;
/*
we treat opened interfaces differently,
we must guard against open
*/
mutex_lock(&acm->mutex);
if (acm->used)
stop_data_traffic(acm);
mutex_unlock(&acm->mutex);
return 0;
}
static void acm_disconnect(struct usb_interface *intf)
{
struct acm *acm = usb_get_intfdata(intf);
struct usb_device *usb_dev = interface_to_usbdev(intf);
/* sibling interface is already cleaning up */
if (!acm)
return;
mutex_lock(&open_mutex);
if (acm->country_codes){
device_remove_file(&acm->control->dev,
&dev_attr_wCountryCodes);
device_remove_file(&acm->control->dev,
&dev_attr_iCountryCodeRelDate);
}
device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
acm->dev = NULL;
usb_set_intfdata(acm->control, NULL);
usb_set_intfdata(acm->data, NULL);
stop_data_traffic(acm);
acm_write_buffers_free(acm);
usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
acm_read_buffers_free(acm);
usb_driver_release_interface(&acm_driver, intf == acm->control ?
acm->data : acm->control);
if (!acm->used) {
acm_tty_unregister(acm);
mutex_unlock(&open_mutex);
return;
}
mutex_unlock(&open_mutex);
if (acm->tty)
tty_hangup(acm->tty);
}
static void modem_disconnect(struct usb_serial *serial)
{
unsigned long flags;
struct modem_port *modem_port_ptr =
usb_get_serial_data(serial);
uint8_t interface_num =
serial->interface->cur_altsetting->desc.bInterfaceNumber;
if (cdma_modem_debug)
dev_info(&serial->dev->dev,
"%s: Disconnect Interface %d\n", __func__,
interface_num);
if (modem_port_ptr->number == MODEM_INTERFACE_NUM) {
/* free BP GPIO wakeup irq */
if (modem_wake_irq) {
disable_irq_wake(modem_wake_irq);
free_irq(modem_wake_irq, modem_port_ptr);
}
wake_lock_destroy(&modem.wakelock);
destroy_workqueue(modem.wq);
}
stop_data_traffic(modem_port_ptr);
cancel_work_sync(&modem_port_ptr->wake_and_write);
/* Request the regulator be shutdown after a timeout. This allows the
other interfaces time to shutdown as well as the BP time to restart
in the case of a panic or some other malfunction. */
spin_lock_irqsave(&modem.lock, flags);
if (modem.connected == true)
{
modem.connected = false;
(void)schedule_delayed_work(&modem.delayed_pwr_shutdown,
msecs_to_jiffies(PWR_DOWN_TIMEOUT_MS));
}
spin_unlock_irqrestore(&modem.lock, flags);
modem_attached_ports--;
}
static int acm_suspend(struct usb_interface *intf, pm_message_t message)
{
struct acm *acm = usb_get_intfdata(intf);
int cnt;
#if 0
if (acm->dev->auto_pm) {
int b;
spin_lock_irq(&acm->read_lock);
spin_lock(&acm->write_lock);
b = acm->processing + acm->transmitting;
spin_unlock(&acm->write_lock);
spin_unlock_irq(&acm->read_lock);
if (b)
return -EBUSY;
}
#endif
spin_lock_irq(&acm->read_lock);
spin_lock(&acm->write_lock);
cnt = acm->susp_count++;
spin_unlock(&acm->write_lock);
spin_unlock_irq(&acm->read_lock);
if (cnt)
return 0;
/*
we treat opened interfaces differently,
we must guard against open
*/
mutex_lock(&acm->mutex);
if (acm->used)
stop_data_traffic(acm);
mutex_unlock(&acm->mutex);
return 0;
}
static int modem_suspend(struct usb_interface *intf,
pm_message_t message)
{
struct usb_serial *serial = usb_get_intfdata(intf);
struct modem_port *modem_port_ptr =
usb_get_serial_data(serial);
struct usb_serial_port *port;
unsigned long flags;
unsigned long threshold_time;
int tmp;
if (modem_port_ptr == NULL) {
dev_err(&intf->dev, " NULL modem_port ptr \n");
return 0;
}
if (cdma_modem_debug)
dev_info(&intf->dev, "%s +++ \n", __func__);
if (modem_port_ptr->number == MODEM_INTERFACE_NUM) {
modem_usb_enable_wakeup_irq(intf);
atomic_set(&modem_port_ptr->wakeup_flag, 0);
}
port = modem_port_ptr->port;
if (port == NULL) {
if (cdma_modem_debug)
dev_info(&intf->dev,
"%s: port not open yet \n",
__func__);
modem_port_ptr->susp_count++;
return 0;
}
if (cdma_modem_debug)
dev_info(&intf->dev, "%s: Suspend Port num %d.\n",
__func__, modem_port_ptr->number);
spin_lock_irqsave(&modem_port_ptr->read_lock, flags);
spin_lock(&modem_port_ptr->write_lock);
tmp = modem_port_ptr->processing + modem_port_ptr->sending;
spin_unlock(&modem_port_ptr->write_lock);
spin_unlock_irqrestore(&modem_port_ptr->read_lock, flags);
if (tmp) {
if (cdma_modem_debug)
dev_info(&intf->dev,
"%s: sending = %d, receiving = %d.\n",
__func__, modem_port_ptr->sending,
modem_port_ptr->processing);
return -EBUSY;
}
threshold_time = modem_port_ptr->last_traffic + MODEM_NO_TRAFFIC_TIME;
if (time_before(jiffies, threshold_time)) {
if (cdma_modem_debug)
dev_info(&intf->dev,
"%s: busy. suspend failed.\n", __func__);
if (modem_port_ptr->number == MODEM_INTERFACE_NUM)
modem_usb_disable_wakeup_irq(intf);
return -EBUSY;
}
spin_lock_irqsave(&modem_port_ptr->read_lock, flags);
spin_lock(&modem_port_ptr->write_lock);
modem_port_ptr->susp_count++;
spin_unlock(&modem_port_ptr->write_lock);
spin_unlock_irqrestore(&modem_port_ptr->read_lock, flags);
stop_data_traffic(modem_port_ptr);
if (cdma_modem_debug)
dev_info(&intf->dev, "%s: Port num %d.suspended\n",
__func__, modem_port_ptr->number);
return 0;
}
