Lines Matching refs:serial
22 * The multiplexed serial ports are using the interrupt and
60 #include <linux/serial.h>
203 on which serial port it is used on. */
230 int (*write_data) (struct hso_serial *serial);
233 * working on the serial receive buffers
294 static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial);
295 static void hso_kick_transmit(struct hso_serial *serial);
312 static int hso_mux_serial_read(struct hso_serial *serial);
369 /* serial structures */
517 static int hso_urb_to_index(struct hso_serial *serial, struct urb *urb)
521 for (idx = 0; idx < serial->num_rx_urbs; idx++)
522 if (serial->rx_urb[idx] == urb)
524 dev_err(serial->parent->dev, "hso_urb_to_index failed\n");
603 struct hso_serial *serial = NULL;
608 serial = dev2ser(serial_table[index]);
611 return serial;
614 static int obtain_minor(struct hso_serial *serial)
622 serial_table[index] = serial->parent;
623 serial->minor = index;
630 pr_err("%s: no free serial devices in table\n", __func__);
634 static void release_minor(struct hso_serial *serial)
639 serial_table[serial->minor] = NULL;
1086 struct hso_serial *serial = tty->driver_data;
1088 if (!serial) {
1093 hso_dbg(0x8, "port %d\n", serial->minor);
1112 static void hso_resubmit_rx_bulk_urb(struct hso_serial *serial, struct urb *urb)
1117 usb_fill_bulk_urb(urb, serial->parent->usb,
1118 usb_rcvbulkpipe(serial->parent->usb,
1119 serial->in_endp->
1121 urb->transfer_buffer, serial->rx_data_length,
1122 hso_std_serial_read_bulk_callback, serial);
1127 dev_err(&urb->dev->dev, "%s failed submit serial rx_urb %d\n",
1135 static void put_rxbuf_data_and_resubmit_bulk_urb(struct hso_serial *serial)
1140 while (serial->rx_urb_filled[serial->curr_rx_urb_idx]) {
1141 curr_urb = serial->rx_urb[serial->curr_rx_urb_idx];
1142 count = put_rxbuf_data(curr_urb, serial);
1146 serial->curr_rx_urb_idx++;
1147 if (serial->curr_rx_urb_idx >= serial->num_rx_urbs)
1148 serial->curr_rx_urb_idx = 0;
1149 hso_resubmit_rx_bulk_urb(serial, curr_urb);
1154 static void put_rxbuf_data_and_resubmit_ctrl_urb(struct hso_serial *serial)
1159 urb = serial->rx_urb[0];
1160 if (serial->port.count > 0) {
1161 count = put_rxbuf_data(urb, serial);
1168 (serial->rx_state == RX_PENDING))) {
1169 serial->rx_state = RX_SENT;
1170 hso_mux_serial_read(serial);
1172 serial->rx_state = RX_IDLE;
1179 struct hso_serial *serial = urb->context;
1186 if (!serial) {
1187 hso_dbg(0x1, "serial == NULL\n");
1191 handle_usb_error(status, __func__, serial->parent);
1199 if (serial->port.count == 0)
1202 if (serial->parent->port_spec & HSO_INFO_CRC_BUG)
1203 fix_crc_bug(urb, serial->in_endp->wMaxPacketSize);
1205 spin_lock_irqsave(&serial->serial_lock, flags);
1206 serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 1;
1207 put_rxbuf_data_and_resubmit_bulk_urb(serial);
1208 spin_unlock_irqrestore(&serial->serial_lock, flags);
1217 struct hso_serial *serial = (struct hso_serial *)data;
1220 spin_lock_irqsave(&serial->serial_lock, flags);
1221 if ((serial->parent->port_spec & HSO_INTF_MUX))
1222 put_rxbuf_data_and_resubmit_ctrl_urb(serial);
1224 put_rxbuf_data_and_resubmit_bulk_urb(serial);
1225 spin_unlock_irqrestore(&serial->serial_lock, flags);
1230 struct hso_serial *serial = tty->driver_data;
1232 tasklet_hi_schedule(&serial->unthrottle_tasklet);
1235 /* open the requested serial port */
1238 struct hso_serial *serial = get_serial_by_index(tty->index);
1242 if (serial == NULL || serial->magic != HSO_SERIAL_MAGIC) {
1249 mutex_lock(&serial->parent->mutex);
1250 result = usb_autopm_get_interface(serial->parent->interface);
1254 hso_dbg(0x1, "Opening %d\n", serial->minor);
1257 tty->driver_data = serial;
1258 tty_port_tty_set(&serial->port, tty);
1261 serial->port.count++;
1262 if (serial->port.count == 1) {
1263 serial->rx_state = RX_IDLE;
1266 tasklet_init(&serial->unthrottle_tasklet,
1268 (unsigned long)serial);
1269 result = hso_start_serial_device(serial->parent, GFP_KERNEL);
1271 hso_stop_serial_device(serial->parent);
1272 serial->port.count--;
1274 kref_get(&serial->parent->ref);
1280 usb_autopm_put_interface(serial->parent->interface);
1286 mutex_unlock(&serial->parent->mutex);
1290 /* close the requested serial port */
1293 struct hso_serial *serial = tty->driver_data;
1296 hso_dbg(0x1, "Closing serial port\n");
1299 if (serial == NULL)
1302 mutex_lock(&serial->parent->mutex);
1303 usb_gone = serial->parent->usb_gone;
1306 usb_autopm_get_interface(serial->parent->interface);
1310 serial->port.count--;
1312 if (serial->port.count <= 0) {
1313 serial->port.count = 0;
1314 tty_port_tty_set(&serial->port, NULL);
1316 hso_stop_serial_device(serial->parent);
1317 tasklet_kill(&serial->unthrottle_tasklet);
1321 usb_autopm_put_interface(serial->parent->interface);
1323 mutex_unlock(&serial->parent->mutex);
1326 /* close the requested serial port */
1330 struct hso_serial *serial = tty->driver_data;
1335 if (serial == NULL) {
1336 pr_err("%s: serial is NULL\n", __func__);
1340 spin_lock_irqsave(&serial->serial_lock, flags);
1342 space = serial->tx_data_length - serial->tx_buffer_count;
1348 memcpy(serial->tx_buffer + serial->tx_buffer_count, buf, tx_bytes);
1349 serial->tx_buffer_count += tx_bytes;
1352 spin_unlock_irqrestore(&serial->serial_lock, flags);
1354 hso_kick_transmit(serial);
1362 struct hso_serial *serial = tty->driver_data;
1366 spin_lock_irqsave(&serial->serial_lock, flags);
1367 room = serial->tx_data_length - serial->tx_buffer_count;
1368 spin_unlock_irqrestore(&serial->serial_lock, flags);
1376 struct hso_serial *serial = tty->driver_data;
1378 if (!serial)
1381 kref_put(&serial->parent->ref, hso_serial_ref_free);
1387 struct hso_serial *serial = tty->driver_data;
1396 spin_lock_irqsave(&serial->serial_lock, flags);
1397 if (serial->port.count)
1401 spin_unlock_irqrestore(&serial->serial_lock, flags);
1409 struct hso_serial *serial = tty->driver_data;
1414 if (serial == NULL)
1417 spin_lock_irqsave(&serial->serial_lock, flags);
1418 chars = serial->tx_buffer_count;
1419 spin_unlock_irqrestore(&serial->serial_lock, flags);
1423 static int tiocmget_submit_urb(struct hso_serial *serial,
1429 if (serial->parent->usb_gone)
1437 tiocmget_intr_callback, serial,
1450 struct hso_serial *serial = urb->context;
1461 if (!serial)
1464 handle_usb_error(status, __func__, serial->parent);
1469 tiocmget = serial->tiocmget;
1472 BUG_ON((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM);
1474 usb = serial->parent->usb;
1475 interface = serial->parent->interface;
1489 "hso received invalid serial state notification\n");
1499 spin_lock_irqsave(&serial->serial_lock, flags);
1522 spin_unlock_irqrestore(&serial->serial_lock, flags);
1528 tiocmget_submit_urb(serial,
1530 serial->parent->usb);
1534 * next few functions largely stolen from drivers/serial/serial_core.c
1542 hso_wait_modem_status(struct hso_serial *serial, unsigned long arg)
1549 tiocmget = serial->tiocmget;
1555 spin_lock_irq(&serial->serial_lock);
1557 spin_unlock_irq(&serial->serial_lock);
1560 spin_lock_irq(&serial->serial_lock);
1562 spin_unlock_irq(&serial->serial_lock);
1585 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1594 struct hso_serial *serial = tty->driver_data;
1595 struct hso_tiocmget *tiocmget = serial->tiocmget;
1601 spin_lock_irq(&serial->serial_lock);
1603 spin_unlock_irq(&serial->serial_lock);
1624 struct hso_serial *serial = tty->driver_data;
1629 if (!serial) {
1633 spin_lock_irq(&serial->serial_lock);
1634 retval = ((serial->rts_state) ? TIOCM_RTS : 0) |
1635 ((serial->dtr_state) ? TIOCM_DTR : 0);
1636 tiocmget = serial->tiocmget;
1648 spin_unlock_irq(&serial->serial_lock);
1658 struct hso_serial *serial = tty->driver_data;
1662 if (!serial) {
1667 if ((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM)
1670 interface = serial->parent->interface;
1673 spin_lock_irqsave(&serial->serial_lock, flags);
1675 serial->rts_state = 1;
1677 serial->dtr_state = 1;
1680 serial->rts_state = 0;
1682 serial->dtr_state = 0;
1684 if (serial->dtr_state)
1686 if (serial->rts_state)
1689 spin_unlock_irqrestore(&serial->serial_lock, flags);
1691 return usb_control_msg(serial->parent->usb,
1692 usb_sndctrlpipe(serial->parent->usb, 0), 0x22,
1700 struct hso_serial *serial = tty->driver_data;
1704 if (!serial)
1708 ret = hso_wait_modem_status(serial, arg);
1719 static void hso_kick_transmit(struct hso_serial *serial)
1724 spin_lock_irqsave(&serial->serial_lock, flags);
1725 if (!serial->tx_buffer_count)
1728 if (serial->tx_urb_used)
1732 if (hso_get_activity(serial->parent) == -EAGAIN)
1736 swap(serial->tx_buffer, serial->tx_data);
1737 serial->tx_data_count = serial->tx_buffer_count;
1738 serial->tx_buffer_count = 0;
1740 /* If serial->tx_data is set, it means we switched buffers */
1741 if (serial->tx_data && serial->write_data) {
1742 res = serial->write_data(serial);
1744 serial->tx_urb_used = 1;
1747 spin_unlock_irqrestore(&serial->serial_lock, flags);
1750 /* make a request (for reading and writing data to muxed serial port) */
1751 static int mux_device_request(struct hso_serial *serial, u8 type, u16 port,
1760 if (!serial || !ctrl_urb || !ctrl_req) {
1776 pipe = usb_rcvctrlpipe(serial->parent->usb, 0);
1783 pipe = usb_sndctrlpipe(serial->parent->usb, 0);
1793 serial->parent->usb,
1796 ctrl_urb_data, size, ctrl_callback, serial);
1811 static int hso_mux_serial_read(struct hso_serial *serial)
1813 if (!serial)
1817 memset(serial->rx_data[0], 0, CTRL_URB_RX_SIZE);
1820 if (serial->num_rx_urbs != 1) {
1821 dev_err(&serial->parent->interface->dev,
1826 return mux_device_request(serial,
1828 serial->parent->port_spec & HSO_PORT_MASK,
1829 serial->rx_urb[0],
1830 &serial->ctrl_req_rx,
1831 serial->rx_data[0], serial->rx_data_length);
1834 /* used for muxed serial port callback (muxed serial read) */
1838 struct hso_serial *serial;
1864 serial = get_serial_by_shared_int_and_type(shared_int,
1866 if (serial != NULL) {
1869 spin_lock_irqsave(&serial->serial_lock, flags);
1870 if (serial->rx_state == RX_IDLE &&
1871 serial->port.count > 0) {
1874 if (!serial->rx_urb_filled[0]) {
1875 serial->rx_state = RX_SENT;
1876 hso_mux_serial_read(serial);
1878 serial->rx_state = RX_PENDING;
1883 spin_unlock_irqrestore(&serial->serial_lock,
1892 /* called for writing to muxed serial port */
1893 static int hso_mux_serial_write_data(struct hso_serial *serial)
1895 if (NULL == serial)
1898 return mux_device_request(serial,
1900 serial->parent->port_spec & HSO_PORT_MASK,
1901 serial->tx_urb,
1902 &serial->ctrl_req_tx,
1903 serial->tx_data, serial->tx_data_count);
1909 struct hso_serial *serial = urb->context;
1914 if (!serial) {
1915 hso_dbg(0x1, "serial == NULL\n");
1919 spin_lock_irqsave(&serial->serial_lock, flags);
1920 serial->tx_urb_used = 0;
1921 spin_unlock_irqrestore(&serial->serial_lock, flags);
1923 handle_usb_error(status, __func__, serial->parent);
1926 hso_put_activity(serial->parent);
1927 tty_port_tty_wakeup(&serial->port);
1928 hso_kick_transmit(serial);
1933 /* called for writing diag or CS serial port */
1934 static int hso_std_serial_write_data(struct hso_serial *serial)
1936 int count = serial->tx_data_count;
1939 usb_fill_bulk_urb(serial->tx_urb,
1940 serial->parent->usb,
1941 usb_sndbulkpipe(serial->parent->usb,
1942 serial->out_endp->
1944 serial->tx_data, serial->tx_data_count,
1945 hso_std_serial_write_bulk_callback, serial);
1947 result = usb_submit_urb(serial->tx_urb, GFP_ATOMIC);
1949 dev_warn(&serial->parent->usb->dev,
1957 /* callback after read or write on muxed serial port */
1960 struct hso_serial *serial = urb->context;
1966 if (!serial)
1969 spin_lock_irqsave(&serial->serial_lock, flags);
1970 serial->tx_urb_used = 0;
1971 spin_unlock_irqrestore(&serial->serial_lock, flags);
1973 handle_usb_error(status, __func__, serial->parent);
1986 serial->rx_urb_filled[0] = 1;
1987 spin_lock_irqsave(&serial->serial_lock, flags);
1988 put_rxbuf_data_and_resubmit_ctrl_urb(serial);
1989 spin_unlock_irqrestore(&serial->serial_lock, flags);
1991 hso_put_activity(serial->parent);
1992 tty_port_tty_wakeup(&serial->port);
1994 hso_kick_transmit(serial);
1998 /* handle RX data for serial port */
1999 static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial)
2005 if (urb == NULL || serial == NULL) {
2006 hso_dbg(0x1, "serial = NULL\n");
2010 tty = tty_port_tty_get(&serial->port);
2019 count = tty_buffer_request_room(&serial->port, urb->actual_length);
2021 tty_insert_flip_string(&serial->port, urb->transfer_buffer,
2023 tty_flip_buffer_push(&serial->port);
2025 dev_warn(&serial->parent->usb->dev,
2031 serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 0;
2144 struct hso_serial *serial = dev2ser(hso_dev);
2146 if (!serial)
2151 if (!(serial->parent->port_spec & HSO_INTF_MUX)) {
2152 for (i = 0; i < serial->num_rx_urbs; i++) {
2153 usb_fill_bulk_urb(serial->rx_urb[i],
2154 serial->parent->usb,
2155 usb_rcvbulkpipe(serial->parent->usb,
2156 serial->in_endp->
2159 serial->rx_data[i],
2160 serial->rx_data_length,
2162 serial);
2163 result = usb_submit_urb(serial->rx_urb[i], flags);
2165 dev_warn(&serial->parent->usb->dev,
2172 mutex_lock(&serial->shared_int->shared_int_lock);
2173 if (!serial->shared_int->use_count) {
2175 hso_mux_submit_intr_urb(serial->shared_int,
2178 serial->shared_int->use_count++;
2179 mutex_unlock(&serial->shared_int->shared_int_lock);
2181 if (serial->tiocmget)
2182 tiocmget_submit_urb(serial,
2183 serial->tiocmget,
2184 serial->parent->usb);
2191 struct hso_serial *serial = dev2ser(hso_dev);
2194 if (!serial)
2197 for (i = 0; i < serial->num_rx_urbs; i++) {
2198 if (serial->rx_urb[i]) {
2199 usb_kill_urb(serial->rx_urb[i]);
2200 serial->rx_urb_filled[i] = 0;
2203 serial->curr_rx_urb_idx = 0;
2205 if (serial->tx_urb)
2206 usb_kill_urb(serial->tx_urb);
2208 if (serial->shared_int) {
2209 mutex_lock(&serial->shared_int->shared_int_lock);
2210 if (serial->shared_int->use_count &&
2211 (--serial->shared_int->use_count == 0)) {
2214 urb = serial->shared_int->shared_intr_urb;
2218 mutex_unlock(&serial->shared_int->shared_int_lock);
2220 tiocmget = serial->tiocmget;
2229 static void hso_serial_tty_unregister(struct hso_serial *serial)
2231 tty_unregister_device(tty_drv, serial->minor);
2232 release_minor(serial);
2235 static void hso_serial_common_free(struct hso_serial *serial)
2239 for (i = 0; i < serial->num_rx_urbs; i++) {
2241 usb_free_urb(serial->rx_urb[i]);
2243 kfree(serial->rx_data[i]);
2247 usb_free_urb(serial->tx_urb);
2248 kfree(serial->tx_buffer);
2249 kfree(serial->tx_data);
2250 tty_port_destroy(&serial->port);
2253 static int hso_serial_common_create(struct hso_serial *serial, int num_urbs,
2258 tty_port_init(&serial->port);
2260 if (obtain_minor(serial))
2264 serial->parent->dev = tty_port_register_device_attr(&serial->port,
2265 tty_drv, serial->minor, &serial->parent->interface->dev,
2266 serial->parent, hso_serial_dev_groups);
2267 if (IS_ERR(serial->parent->dev)) {
2268 release_minor(serial);
2272 serial->magic = HSO_SERIAL_MAGIC;
2273 spin_lock_init(&serial->serial_lock);
2274 serial->num_rx_urbs = num_urbs;
2279 serial->rx_data_length = rx_size;
2280 for (i = 0; i < serial->num_rx_urbs; i++) {
2281 serial->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
2282 if (!serial->rx_urb[i])
2284 serial->rx_urb[i]->transfer_buffer = NULL;
2285 serial->rx_urb[i]->transfer_buffer_length = 0;
2286 serial->rx_data[i] = kzalloc(serial->rx_data_length,
2288 if (!serial->rx_data[i])
2293 serial->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
2294 if (!serial->tx_urb)
2296 serial->tx_urb->transfer_buffer = NULL;
2297 serial->tx_urb->transfer_buffer_length = 0;
2299 serial->tx_data_count = 0;
2300 serial->tx_buffer_count = 0;
2301 serial->tx_data_length = tx_size;
2302 serial->tx_data = kzalloc(serial->tx_data_length, GFP_KERNEL);
2303 if (!serial->tx_data)
2306 serial->tx_buffer = kzalloc(serial->tx_data_length, GFP_KERNEL);
2307 if (!serial->tx_buffer)
2312 hso_serial_tty_unregister(serial);
2314 hso_serial_common_free(serial);
2577 static void hso_free_tiomget(struct hso_serial *serial)
2580 if (!serial)
2582 tiocmget = serial->tiocmget;
2586 serial->tiocmget = NULL;
2596 struct hso_serial *serial = dev2ser(hso_dev);
2598 if (!serial)
2601 hso_serial_common_free(serial);
2603 if (serial->shared_int) {
2604 mutex_lock(&serial->shared_int->shared_int_lock);
2605 if (--serial->shared_int->ref_count == 0)
2606 hso_free_shared_int(serial->shared_int);
2608 mutex_unlock(&serial->shared_int->shared_int_lock);
2610 hso_free_tiomget(serial);
2611 kfree(serial);
2620 struct hso_serial *serial;
2628 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
2629 if (!serial)
2632 serial->parent = hso_dev;
2633 hso_dev->port_data.dev_serial = serial;
2637 serial->tiocmget = kzalloc(sizeof(struct hso_tiocmget),
2639 if (!serial->tiocmget)
2641 serial->tiocmget->serial_state_notification
2644 if (!serial->tiocmget->serial_state_notification)
2646 tiocmget = serial->tiocmget;
2665 if (hso_serial_common_create(serial, num_urbs, BULK_URB_RX_SIZE,
2669 serial->in_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,
2671 if (!serial->in_endp) {
2677 (serial->out_endp =
2683 serial->write_data = hso_std_serial_write_data;
2692 hso_serial_tty_unregister(serial);
2693 hso_serial_common_free(serial);
2695 hso_free_tiomget(serial);
2696 kfree(serial);
2708 struct hso_serial *serial;
2722 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
2723 if (!serial)
2726 hso_dev->port_data.dev_serial = serial;
2727 serial->parent = hso_dev;
2730 (serial, 1, CTRL_URB_RX_SIZE, CTRL_URB_TX_SIZE))
2733 serial->tx_data_length--;
2734 serial->write_data = hso_mux_serial_write_data;
2736 serial->shared_int = mux;
2737 mutex_lock(&serial->shared_int->shared_int_lock);
2738 serial->shared_int->ref_count++;
2739 mutex_unlock(&serial->shared_int->shared_int_lock);
2748 kfree(serial);
3030 /* Stop all serial ports */
3059 /* Start all serial ports */
3108 struct hso_serial *serial;
3114 serial = dev2ser(serial_table[i]);
3115 tty_port_tty_hangup(&serial->port, false);
3116 mutex_lock(&serial->parent->mutex);
3117 serial->parent->usb_gone = 1;
3118 mutex_unlock(&serial->parent->mutex);
3121 hso_serial_tty_unregister(serial);
3122 kref_put(&serial->parent->ref, hso_serial_ref_free);
3186 /* interrupt urb needs to be submitted, used for serial read of muxed port */
3208 /* operations setup of the serial interface */
3244 /* Initialise the serial table semaphore and table */