Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved. */
0003 
0004 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0005 
0006 #include <linux/module.h>
0007 #include <linux/kernel.h>
0008 #include <linux/usb.h>
0009 #include <linux/errno.h>
0010 #include <linux/init.h>
0011 #include <linux/tty.h>
0012 #include <linux/tty_driver.h>
0013 #include <linux/tty_flip.h>
0014 #include <linux/slab.h>
0015 #include <linux/usb/cdc.h>
0016 
0017 #include "gdm_mux.h"
0018 
0019 static u16 packet_type_for_tty_index[TTY_MAX_COUNT] = {0xF011, 0xF010};
0020 
0021 #define USB_DEVICE_CDC_DATA(vid, pid) \
0022     .match_flags = \
0023         USB_DEVICE_ID_MATCH_DEVICE |\
0024         USB_DEVICE_ID_MATCH_INT_CLASS |\
0025         USB_DEVICE_ID_MATCH_INT_SUBCLASS,\
0026     .idVendor = vid,\
0027     .idProduct = pid,\
0028     .bInterfaceClass = USB_CLASS_COMM,\
0029     .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM
0030 
0031 static const struct usb_device_id id_table[] = {
0032     { USB_DEVICE_CDC_DATA(0x1076, 0x8000) }, /* GCT GDM7240 */
0033     { USB_DEVICE_CDC_DATA(0x1076, 0x8f00) }, /* GCT GDM7243 */
0034     { USB_DEVICE_CDC_DATA(0x1076, 0x9000) }, /* GCT GDM7243 */
0035     { USB_DEVICE_CDC_DATA(0x1d74, 0x2300) }, /* LGIT Phoenix */
0036     {}
0037 };
0038 
0039 MODULE_DEVICE_TABLE(usb, id_table);
0040 
0041 static int packet_type_to_tty_index(u16 packet_type)
0042 {
0043     int i;
0044 
0045     for (i = 0; i < TTY_MAX_COUNT; i++) {
0046         if (packet_type_for_tty_index[i] == packet_type)
0047             return i;
0048     }
0049 
0050     return -1;
0051 }
0052 
0053 static struct mux_tx *alloc_mux_tx(int len)
0054 {
0055     struct mux_tx *t;
0056 
0057     t = kzalloc(sizeof(*t), GFP_ATOMIC);
0058     if (!t)
0059         return NULL;
0060 
0061     t->urb = usb_alloc_urb(0, GFP_ATOMIC);
0062     t->buf = kmalloc(MUX_TX_MAX_SIZE, GFP_ATOMIC);
0063     if (!t->urb || !t->buf) {
0064         usb_free_urb(t->urb);
0065         kfree(t->buf);
0066         kfree(t);
0067         return NULL;
0068     }
0069 
0070     return t;
0071 }
0072 
0073 static void free_mux_tx(struct mux_tx *t)
0074 {
0075     if (t) {
0076         usb_free_urb(t->urb);
0077         kfree(t->buf);
0078         kfree(t);
0079     }
0080 }
0081 
0082 static struct mux_rx *alloc_mux_rx(void)
0083 {
0084     struct mux_rx *r;
0085 
0086     r = kzalloc(sizeof(*r), GFP_KERNEL);
0087     if (!r)
0088         return NULL;
0089 
0090     r->urb = usb_alloc_urb(0, GFP_KERNEL);
0091     r->buf = kmalloc(MUX_RX_MAX_SIZE, GFP_KERNEL);
0092     if (!r->urb || !r->buf) {
0093         usb_free_urb(r->urb);
0094         kfree(r->buf);
0095         kfree(r);
0096         return NULL;
0097     }
0098 
0099     return r;
0100 }
0101 
0102 static void free_mux_rx(struct mux_rx *r)
0103 {
0104     if (r) {
0105         usb_free_urb(r->urb);
0106         kfree(r->buf);
0107         kfree(r);
0108     }
0109 }
0110 
0111 static struct mux_rx *get_rx_struct(struct rx_cxt *rx)
0112 {
0113     struct mux_rx *r;
0114     unsigned long flags;
0115 
0116     spin_lock_irqsave(&rx->free_list_lock, flags);
0117 
0118     if (list_empty(&rx->rx_free_list)) {
0119         spin_unlock_irqrestore(&rx->free_list_lock, flags);
0120         return NULL;
0121     }
0122 
0123     r = list_entry(rx->rx_free_list.prev, struct mux_rx, free_list);
0124     list_del(&r->free_list);
0125 
0126     spin_unlock_irqrestore(&rx->free_list_lock, flags);
0127 
0128     return r;
0129 }
0130 
0131 static void put_rx_struct(struct rx_cxt *rx, struct mux_rx *r)
0132 {
0133     unsigned long flags;
0134 
0135     spin_lock_irqsave(&rx->free_list_lock, flags);
0136     list_add_tail(&r->free_list, &rx->rx_free_list);
0137     spin_unlock_irqrestore(&rx->free_list_lock, flags);
0138 }
0139 
0140 static int up_to_host(struct mux_rx *r)
0141 {
0142     struct mux_dev *mux_dev = r->mux_dev;
0143     struct mux_pkt_header *mux_header;
0144     unsigned int start_flag;
0145     unsigned int payload_size;
0146     unsigned short packet_type;
0147     int total_len;
0148     u32 packet_size_sum = r->offset;
0149     int index;
0150     int ret = TO_HOST_INVALID_PACKET;
0151     int len = r->len;
0152 
0153     while (1) {
0154         mux_header = (struct mux_pkt_header *)(r->buf +
0155                                packet_size_sum);
0156         start_flag = __le32_to_cpu(mux_header->start_flag);
0157         payload_size = __le32_to_cpu(mux_header->payload_size);
0158         packet_type = __le16_to_cpu(mux_header->packet_type);
0159 
0160         if (start_flag != START_FLAG) {
0161             pr_err("invalid START_FLAG %x\n", start_flag);
0162             break;
0163         }
0164 
0165         total_len = ALIGN(MUX_HEADER_SIZE + payload_size, 4);
0166 
0167         if (len - packet_size_sum < total_len) {
0168             pr_err("invalid payload : %d %d %04x\n",
0169                    payload_size, len, packet_type);
0170             break;
0171         }
0172 
0173         index = packet_type_to_tty_index(packet_type);
0174         if (index < 0) {
0175             pr_err("invalid index %d\n", index);
0176             break;
0177         }
0178 
0179         ret = r->callback(mux_header->data,
0180                 payload_size,
0181                 index,
0182                 mux_dev->tty_dev,
0183                 RECV_PACKET_PROCESS_CONTINUE
0184                 );
0185         if (ret == TO_HOST_BUFFER_REQUEST_FAIL) {
0186             r->offset += packet_size_sum;
0187             break;
0188         }
0189 
0190         packet_size_sum += total_len;
0191         if (len - packet_size_sum <= MUX_HEADER_SIZE + 2) {
0192             ret = r->callback(NULL,
0193                     0,
0194                     index,
0195                     mux_dev->tty_dev,
0196                     RECV_PACKET_PROCESS_COMPLETE
0197                     );
0198             break;
0199         }
0200     }
0201 
0202     return ret;
0203 }
0204 
0205 static void do_rx(struct work_struct *work)
0206 {
0207     struct mux_dev *mux_dev =
0208         container_of(work, struct mux_dev, work_rx.work);
0209     struct mux_rx *r;
0210     struct rx_cxt *rx = &mux_dev->rx;
0211     unsigned long flags;
0212     int ret = 0;
0213 
0214     while (1) {
0215         spin_lock_irqsave(&rx->to_host_lock, flags);
0216         if (list_empty(&rx->to_host_list)) {
0217             spin_unlock_irqrestore(&rx->to_host_lock, flags);
0218             break;
0219         }
0220         r = list_entry(rx->to_host_list.next, struct mux_rx,
0221                    to_host_list);
0222         list_del(&r->to_host_list);
0223         spin_unlock_irqrestore(&rx->to_host_lock, flags);
0224 
0225         ret = up_to_host(r);
0226         if (ret == TO_HOST_BUFFER_REQUEST_FAIL)
0227             pr_err("failed to send mux data to host\n");
0228         else
0229             put_rx_struct(rx, r);
0230     }
0231 }
0232 
0233 static void remove_rx_submit_list(struct mux_rx *r, struct rx_cxt *rx)
0234 {
0235     unsigned long flags;
0236     struct mux_rx   *r_remove, *r_remove_next;
0237 
0238     spin_lock_irqsave(&rx->submit_list_lock, flags);
0239     list_for_each_entry_safe(r_remove, r_remove_next, &rx->rx_submit_list,
0240                  rx_submit_list) {
0241         if (r == r_remove)
0242             list_del(&r->rx_submit_list);
0243     }
0244     spin_unlock_irqrestore(&rx->submit_list_lock, flags);
0245 }
0246 
0247 static void gdm_mux_rcv_complete(struct urb *urb)
0248 {
0249     struct mux_rx *r = urb->context;
0250     struct mux_dev *mux_dev = r->mux_dev;
0251     struct rx_cxt *rx = &mux_dev->rx;
0252     unsigned long flags;
0253 
0254     remove_rx_submit_list(r, rx);
0255 
0256     if (urb->status) {
0257         if (mux_dev->usb_state == PM_NORMAL)
0258             dev_err(&urb->dev->dev, "%s: urb status error %d\n",
0259                 __func__, urb->status);
0260         put_rx_struct(rx, r);
0261     } else {
0262         r->len = r->urb->actual_length;
0263         spin_lock_irqsave(&rx->to_host_lock, flags);
0264         list_add_tail(&r->to_host_list, &rx->to_host_list);
0265         schedule_work(&mux_dev->work_rx.work);
0266         spin_unlock_irqrestore(&rx->to_host_lock, flags);
0267     }
0268 }
0269 
0270 static int gdm_mux_recv(void *priv_dev,
0271             int (*cb)(void *data, int len, int tty_index,
0272                   struct tty_dev *tty_dev, int complete))
0273 {
0274     struct mux_dev *mux_dev = priv_dev;
0275     struct usb_device *usbdev = mux_dev->usbdev;
0276     struct mux_rx *r;
0277     struct rx_cxt *rx = &mux_dev->rx;
0278     unsigned long flags;
0279     int ret;
0280 
0281     if (!usbdev) {
0282         pr_err("device is disconnected\n");
0283         return -ENODEV;
0284     }
0285 
0286     r = get_rx_struct(rx);
0287     if (!r) {
0288         pr_err("get_rx_struct fail\n");
0289         return -ENOMEM;
0290     }
0291 
0292     r->offset = 0;
0293     r->mux_dev = (void *)mux_dev;
0294     r->callback = cb;
0295     mux_dev->rx_cb = cb;
0296 
0297     usb_fill_bulk_urb(r->urb,
0298               usbdev,
0299               usb_rcvbulkpipe(usbdev, 0x86),
0300               r->buf,
0301               MUX_RX_MAX_SIZE,
0302               gdm_mux_rcv_complete,
0303               r);
0304 
0305     spin_lock_irqsave(&rx->submit_list_lock, flags);
0306     list_add_tail(&r->rx_submit_list, &rx->rx_submit_list);
0307     spin_unlock_irqrestore(&rx->submit_list_lock, flags);
0308 
0309     ret = usb_submit_urb(r->urb, GFP_KERNEL);
0310 
0311     if (ret) {
0312         spin_lock_irqsave(&rx->submit_list_lock, flags);
0313         list_del(&r->rx_submit_list);
0314         spin_unlock_irqrestore(&rx->submit_list_lock, flags);
0315 
0316         put_rx_struct(rx, r);
0317 
0318         pr_err("usb_submit_urb ret=%d\n", ret);
0319     }
0320 
0321     usb_mark_last_busy(usbdev);
0322 
0323     return ret;
0324 }
0325 
0326 static void gdm_mux_send_complete(struct urb *urb)
0327 {
0328     struct mux_tx *t = urb->context;
0329 
0330     if (urb->status == -ECONNRESET) {
0331         dev_info(&urb->dev->dev, "CONNRESET\n");
0332         free_mux_tx(t);
0333         return;
0334     }
0335 
0336     if (t->callback)
0337         t->callback(t->cb_data);
0338 
0339     free_mux_tx(t);
0340 }
0341 
0342 static int gdm_mux_send(void *priv_dev, void *data, int len, int tty_index,
0343             void (*cb)(void *data), void *cb_data)
0344 {
0345     struct mux_dev *mux_dev = priv_dev;
0346     struct usb_device *usbdev = mux_dev->usbdev;
0347     struct mux_pkt_header *mux_header;
0348     struct mux_tx *t = NULL;
0349     static u32 seq_num = 1;
0350     int total_len;
0351     int ret;
0352     unsigned long flags;
0353 
0354     if (mux_dev->usb_state == PM_SUSPEND) {
0355         ret = usb_autopm_get_interface(mux_dev->intf);
0356         if (!ret)
0357             usb_autopm_put_interface(mux_dev->intf);
0358     }
0359 
0360     spin_lock_irqsave(&mux_dev->write_lock, flags);
0361 
0362     total_len = ALIGN(MUX_HEADER_SIZE + len, 4);
0363 
0364     t = alloc_mux_tx(total_len);
0365     if (!t) {
0366         pr_err("alloc_mux_tx fail\n");
0367         spin_unlock_irqrestore(&mux_dev->write_lock, flags);
0368         return -ENOMEM;
0369     }
0370 
0371     mux_header = (struct mux_pkt_header *)t->buf;
0372     mux_header->start_flag = __cpu_to_le32(START_FLAG);
0373     mux_header->seq_num = __cpu_to_le32(seq_num++);
0374     mux_header->payload_size = __cpu_to_le32((u32)len);
0375     mux_header->packet_type = __cpu_to_le16(packet_type_for_tty_index[tty_index]);
0376 
0377     memcpy(t->buf + MUX_HEADER_SIZE, data, len);
0378     memset(t->buf + MUX_HEADER_SIZE + len, 0,
0379            total_len - MUX_HEADER_SIZE - len);
0380 
0381     t->len = total_len;
0382     t->callback = cb;
0383     t->cb_data = cb_data;
0384 
0385     usb_fill_bulk_urb(t->urb,
0386               usbdev,
0387               usb_sndbulkpipe(usbdev, 5),
0388               t->buf,
0389               total_len,
0390               gdm_mux_send_complete,
0391               t);
0392 
0393     ret = usb_submit_urb(t->urb, GFP_ATOMIC);
0394 
0395     spin_unlock_irqrestore(&mux_dev->write_lock, flags);
0396 
0397     if (ret)
0398         pr_err("usb_submit_urb Error: %d\n", ret);
0399 
0400     usb_mark_last_busy(usbdev);
0401 
0402     return ret;
0403 }
0404 
0405 static int gdm_mux_send_control(void *priv_dev, int request, int value,
0406                 void *buf, int len)
0407 {
0408     struct mux_dev *mux_dev = priv_dev;
0409     struct usb_device *usbdev = mux_dev->usbdev;
0410     int ret;
0411 
0412     ret = usb_control_msg(usbdev,
0413                   usb_sndctrlpipe(usbdev, 0),
0414                   request,
0415                   USB_RT_ACM,
0416                   value,
0417                   2,
0418                   buf,
0419                   len,
0420                   5000
0421                  );
0422 
0423     if (ret < 0)
0424         pr_err("usb_control_msg error: %d\n", ret);
0425 
0426     return min(ret, 0);
0427 }
0428 
0429 static void release_usb(struct mux_dev *mux_dev)
0430 {
0431     struct rx_cxt       *rx = &mux_dev->rx;
0432     struct mux_rx       *r, *r_next;
0433     unsigned long       flags;
0434 
0435     cancel_delayed_work(&mux_dev->work_rx);
0436 
0437     spin_lock_irqsave(&rx->submit_list_lock, flags);
0438     list_for_each_entry_safe(r, r_next, &rx->rx_submit_list,
0439                  rx_submit_list) {
0440         spin_unlock_irqrestore(&rx->submit_list_lock, flags);
0441         usb_kill_urb(r->urb);
0442         spin_lock_irqsave(&rx->submit_list_lock, flags);
0443     }
0444     spin_unlock_irqrestore(&rx->submit_list_lock, flags);
0445 
0446     spin_lock_irqsave(&rx->free_list_lock, flags);
0447     list_for_each_entry_safe(r, r_next, &rx->rx_free_list, free_list) {
0448         list_del(&r->free_list);
0449         free_mux_rx(r);
0450     }
0451     spin_unlock_irqrestore(&rx->free_list_lock, flags);
0452 
0453     spin_lock_irqsave(&rx->to_host_lock, flags);
0454     list_for_each_entry_safe(r, r_next, &rx->to_host_list, to_host_list) {
0455         if (r->mux_dev == (void *)mux_dev) {
0456             list_del(&r->to_host_list);
0457             free_mux_rx(r);
0458         }
0459     }
0460     spin_unlock_irqrestore(&rx->to_host_lock, flags);
0461 }
0462 
0463 static int init_usb(struct mux_dev *mux_dev)
0464 {
0465     struct mux_rx *r;
0466     struct rx_cxt *rx = &mux_dev->rx;
0467     int ret = 0;
0468     int i;
0469 
0470     spin_lock_init(&mux_dev->write_lock);
0471     INIT_LIST_HEAD(&rx->to_host_list);
0472     INIT_LIST_HEAD(&rx->rx_submit_list);
0473     INIT_LIST_HEAD(&rx->rx_free_list);
0474     spin_lock_init(&rx->to_host_lock);
0475     spin_lock_init(&rx->submit_list_lock);
0476     spin_lock_init(&rx->free_list_lock);
0477 
0478     for (i = 0; i < MAX_ISSUE_NUM * 2; i++) {
0479         r = alloc_mux_rx();
0480         if (!r) {
0481             ret = -ENOMEM;
0482             break;
0483         }
0484 
0485         list_add(&r->free_list, &rx->rx_free_list);
0486     }
0487 
0488     INIT_DELAYED_WORK(&mux_dev->work_rx, do_rx);
0489 
0490     return ret;
0491 }
0492 
0493 static int gdm_mux_probe(struct usb_interface *intf,
0494              const struct usb_device_id *id)
0495 {
0496     struct mux_dev *mux_dev;
0497     struct tty_dev *tty_dev;
0498     u16 idVendor, idProduct;
0499     int bInterfaceNumber;
0500     int ret;
0501     int i;
0502     struct usb_device *usbdev = interface_to_usbdev(intf);
0503 
0504     bInterfaceNumber = intf->cur_altsetting->desc.bInterfaceNumber;
0505 
0506     idVendor = __le16_to_cpu(usbdev->descriptor.idVendor);
0507     idProduct = __le16_to_cpu(usbdev->descriptor.idProduct);
0508 
0509     pr_info("mux vid = 0x%04x pid = 0x%04x\n", idVendor, idProduct);
0510 
0511     if (bInterfaceNumber != 2)
0512         return -ENODEV;
0513 
0514     mux_dev = kzalloc(sizeof(*mux_dev), GFP_KERNEL);
0515     if (!mux_dev)
0516         return -ENOMEM;
0517 
0518     tty_dev = kzalloc(sizeof(*tty_dev), GFP_KERNEL);
0519     if (!tty_dev) {
0520         ret = -ENOMEM;
0521         goto err_free_mux;
0522     }
0523 
0524     mux_dev->usbdev = usbdev;
0525     mux_dev->control_intf = intf;
0526 
0527     ret = init_usb(mux_dev);
0528     if (ret)
0529         goto err_free_usb;
0530 
0531     tty_dev->priv_dev = (void *)mux_dev;
0532     tty_dev->send_func = gdm_mux_send;
0533     tty_dev->recv_func = gdm_mux_recv;
0534     tty_dev->send_control = gdm_mux_send_control;
0535 
0536     ret = register_lte_tty_device(tty_dev, &intf->dev);
0537     if (ret)
0538         goto err_unregister_tty;
0539 
0540     for (i = 0; i < TTY_MAX_COUNT; i++)
0541         mux_dev->tty_dev = tty_dev;
0542 
0543     mux_dev->intf = intf;
0544     mux_dev->usb_state = PM_NORMAL;
0545 
0546     usb_get_dev(usbdev);
0547     usb_set_intfdata(intf, tty_dev);
0548 
0549     return 0;
0550 
0551 err_unregister_tty:
0552     unregister_lte_tty_device(tty_dev);
0553 err_free_usb:
0554     release_usb(mux_dev);
0555     kfree(tty_dev);
0556 err_free_mux:
0557     kfree(mux_dev);
0558 
0559     return ret;
0560 }
0561 
0562 static void gdm_mux_disconnect(struct usb_interface *intf)
0563 {
0564     struct tty_dev *tty_dev;
0565     struct mux_dev *mux_dev;
0566     struct usb_device *usbdev = interface_to_usbdev(intf);
0567 
0568     tty_dev = usb_get_intfdata(intf);
0569 
0570     mux_dev = tty_dev->priv_dev;
0571 
0572     release_usb(mux_dev);
0573     unregister_lte_tty_device(tty_dev);
0574 
0575     kfree(mux_dev);
0576     kfree(tty_dev);
0577 
0578     usb_put_dev(usbdev);
0579 }
0580 
0581 static int gdm_mux_suspend(struct usb_interface *intf, pm_message_t pm_msg)
0582 {
0583     struct tty_dev *tty_dev;
0584     struct mux_dev *mux_dev;
0585     struct rx_cxt *rx;
0586     struct mux_rx *r, *r_next;
0587     unsigned long flags;
0588 
0589     tty_dev = usb_get_intfdata(intf);
0590     mux_dev = tty_dev->priv_dev;
0591     rx = &mux_dev->rx;
0592 
0593     cancel_work_sync(&mux_dev->work_rx.work);
0594 
0595     if (mux_dev->usb_state != PM_NORMAL) {
0596         dev_err(intf->usb_dev, "usb suspend - invalid state\n");
0597         return -1;
0598     }
0599 
0600     mux_dev->usb_state = PM_SUSPEND;
0601 
0602     spin_lock_irqsave(&rx->submit_list_lock, flags);
0603     list_for_each_entry_safe(r, r_next, &rx->rx_submit_list,
0604                  rx_submit_list) {
0605         spin_unlock_irqrestore(&rx->submit_list_lock, flags);
0606         usb_kill_urb(r->urb);
0607         spin_lock_irqsave(&rx->submit_list_lock, flags);
0608     }
0609     spin_unlock_irqrestore(&rx->submit_list_lock, flags);
0610 
0611     return 0;
0612 }
0613 
0614 static int gdm_mux_resume(struct usb_interface *intf)
0615 {
0616     struct tty_dev *tty_dev;
0617     struct mux_dev *mux_dev;
0618     u8 i;
0619 
0620     tty_dev = usb_get_intfdata(intf);
0621     mux_dev = tty_dev->priv_dev;
0622 
0623     if (mux_dev->usb_state != PM_SUSPEND) {
0624         dev_err(intf->usb_dev, "usb resume - invalid state\n");
0625         return -1;
0626     }
0627 
0628     mux_dev->usb_state = PM_NORMAL;
0629 
0630     for (i = 0; i < MAX_ISSUE_NUM; i++)
0631         gdm_mux_recv(mux_dev, mux_dev->rx_cb);
0632 
0633     return 0;
0634 }
0635 
0636 static struct usb_driver gdm_mux_driver = {
0637     .name = "gdm_mux",
0638     .probe = gdm_mux_probe,
0639     .disconnect = gdm_mux_disconnect,
0640     .id_table = id_table,
0641     .supports_autosuspend = 1,
0642     .suspend = gdm_mux_suspend,
0643     .resume = gdm_mux_resume,
0644     .reset_resume = gdm_mux_resume,
0645 };
0646 
0647 static int __init gdm_usb_mux_init(void)
0648 {
0649     int ret;
0650 
0651     ret = register_lte_tty_driver();
0652     if (ret)
0653         return ret;
0654 
0655     return usb_register(&gdm_mux_driver);
0656 }
0657 
0658 static void __exit gdm_usb_mux_exit(void)
0659 {
0660     usb_deregister(&gdm_mux_driver);
0661     unregister_lte_tty_driver();
0662 }
0663 
0664 module_init(gdm_usb_mux_init);
0665 module_exit(gdm_usb_mux_exit);
0666 
0667 MODULE_DESCRIPTION("GCT LTE TTY Device Driver");
0668 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!