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 */
516 static int hso_urb_to_index(struct hso_serial *serial, struct urb *urb)
520 for (idx = 0; idx < serial->num_rx_urbs; idx++)
521 if (serial->rx_urb[idx] == urb)
523 dev_err(serial->parent->dev, "hso_urb_to_index failed\n");
602 struct hso_serial *serial = NULL;
607 serial = dev2ser(serial_table[index]);
610 return serial;
613 static int obtain_minor(struct hso_serial *serial)
621 serial_table[index] = serial->parent;
622 serial->minor = index;
629 pr_err("%s: no free serial devices in table\n", __func__);
633 static void release_minor(struct hso_serial *serial)
638 serial_table[serial->minor] = NULL;
1084 struct hso_serial *serial = tty->driver_data;
1086 if (!serial) {
1091 hso_dbg(0x8, "port %d\n", serial->minor);
1110 static void hso_resubmit_rx_bulk_urb(struct hso_serial *serial, struct urb *urb)
1115 usb_fill_bulk_urb(urb, serial->parent->usb,
1116 usb_rcvbulkpipe(serial->parent->usb,
1117 serial->in_endp->
1119 urb->transfer_buffer, serial->rx_data_length,
1120 hso_std_serial_read_bulk_callback, serial);
1125 dev_err(&urb->dev->dev, "%s failed submit serial rx_urb %d\n",
1133 static void put_rxbuf_data_and_resubmit_bulk_urb(struct hso_serial *serial)
1138 while (serial->rx_urb_filled[serial->curr_rx_urb_idx]) {
1139 curr_urb = serial->rx_urb[serial->curr_rx_urb_idx];
1140 count = put_rxbuf_data(curr_urb, serial);
1144 serial->curr_rx_urb_idx++;
1145 if (serial->curr_rx_urb_idx >= serial->num_rx_urbs)
1146 serial->curr_rx_urb_idx = 0;
1147 hso_resubmit_rx_bulk_urb(serial, curr_urb);
1152 static void put_rxbuf_data_and_resubmit_ctrl_urb(struct hso_serial *serial)
1157 urb = serial->rx_urb[0];
1158 if (serial->port.count > 0) {
1159 count = put_rxbuf_data(urb, serial);
1166 (serial->rx_state == RX_PENDING))) {
1167 serial->rx_state = RX_SENT;
1168 hso_mux_serial_read(serial);
1170 serial->rx_state = RX_IDLE;
1177 struct hso_serial *serial = urb->context;
1184 if (!serial) {
1185 hso_dbg(0x1, "serial == NULL\n");
1189 handle_usb_error(status, __func__, serial->parent);
1197 if (serial->port.count == 0)
1200 if (serial->parent->port_spec & HSO_INFO_CRC_BUG)
1201 fix_crc_bug(urb, serial->in_endp->wMaxPacketSize);
1203 spin_lock_irqsave(&serial->serial_lock, flags);
1204 serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 1;
1205 put_rxbuf_data_and_resubmit_bulk_urb(serial);
1206 spin_unlock_irqrestore(&serial->serial_lock, flags);
1215 struct hso_serial *serial = from_tasklet(serial, t,
1219 spin_lock_irqsave(&serial->serial_lock, flags);
1220 if ((serial->parent->port_spec & HSO_INTF_MUX))
1221 put_rxbuf_data_and_resubmit_ctrl_urb(serial);
1223 put_rxbuf_data_and_resubmit_bulk_urb(serial);
1224 spin_unlock_irqrestore(&serial->serial_lock, flags);
1229 struct hso_serial *serial = tty->driver_data;
1231 tasklet_hi_schedule(&serial->unthrottle_tasklet);
1234 /* open the requested serial port */
1237 struct hso_serial *serial = get_serial_by_index(tty->index);
1241 if (serial == NULL || serial->magic != HSO_SERIAL_MAGIC) {
1248 mutex_lock(&serial->parent->mutex);
1249 result = usb_autopm_get_interface(serial->parent->interface);
1253 hso_dbg(0x1, "Opening %d\n", serial->minor);
1256 tty->driver_data = serial;
1257 tty_port_tty_set(&serial->port, tty);
1260 serial->port.count++;
1261 if (serial->port.count == 1) {
1262 serial->rx_state = RX_IDLE;
1265 tasklet_setup(&serial->unthrottle_tasklet,
1267 result = hso_start_serial_device(serial->parent, GFP_KERNEL);
1269 hso_stop_serial_device(serial->parent);
1270 serial->port.count--;
1272 kref_get(&serial->parent->ref);
1278 usb_autopm_put_interface(serial->parent->interface);
1284 mutex_unlock(&serial->parent->mutex);
1288 /* close the requested serial port */
1291 struct hso_serial *serial = tty->driver_data;
1294 hso_dbg(0x1, "Closing serial port\n");
1297 if (serial == NULL)
1300 mutex_lock(&serial->parent->mutex);
1301 usb_gone = serial->parent->usb_gone;
1304 usb_autopm_get_interface(serial->parent->interface);
1308 serial->port.count--;
1310 if (serial->port.count <= 0) {
1311 serial->port.count = 0;
1312 tty_port_tty_set(&serial->port, NULL);
1314 hso_stop_serial_device(serial->parent);
1315 tasklet_kill(&serial->unthrottle_tasklet);
1319 usb_autopm_put_interface(serial->parent->interface);
1321 mutex_unlock(&serial->parent->mutex);
1324 /* close the requested serial port */
1328 struct hso_serial *serial = tty->driver_data;
1332 if (serial == NULL) {
1333 pr_err("%s: serial is NULL\n", __func__);
1337 spin_lock_irqsave(&serial->serial_lock, flags);
1339 count = min_t(size_t, serial->tx_data_length - serial->tx_buffer_count,
1341 memcpy(serial->tx_buffer + serial->tx_buffer_count, buf, count);
1342 serial->tx_buffer_count += count;
1344 spin_unlock_irqrestore(&serial->serial_lock, flags);
1346 hso_kick_transmit(serial);
1354 struct hso_serial *serial = tty->driver_data;
1358 spin_lock_irqsave(&serial->serial_lock, flags);
1359 room = serial->tx_data_length - serial->tx_buffer_count;
1360 spin_unlock_irqrestore(&serial->serial_lock, flags);
1368 struct hso_serial *serial = tty->driver_data;
1370 if (!serial)
1373 kref_put(&serial->parent->ref, hso_serial_ref_free);
1380 struct hso_serial *serial = tty->driver_data;
1389 spin_lock_irqsave(&serial->serial_lock, flags);
1390 if (serial->port.count)
1394 spin_unlock_irqrestore(&serial->serial_lock, flags);
1402 struct hso_serial *serial = tty->driver_data;
1407 if (serial == NULL)
1410 spin_lock_irqsave(&serial->serial_lock, flags);
1411 chars = serial->tx_buffer_count;
1412 spin_unlock_irqrestore(&serial->serial_lock, flags);
1416 static int tiocmget_submit_urb(struct hso_serial *serial,
1422 if (serial->parent->usb_gone)
1430 tiocmget_intr_callback, serial,
1443 struct hso_serial *serial = urb->context;
1454 if (!serial)
1457 handle_usb_error(status, __func__, serial->parent);
1462 tiocmget = serial->tiocmget;
1465 BUG_ON((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM);
1467 usb = serial->parent->usb;
1468 interface = serial->parent->interface;
1482 "hso received invalid serial state notification\n");
1492 spin_lock_irqsave(&serial->serial_lock, flags);
1515 spin_unlock_irqrestore(&serial->serial_lock, flags);
1521 tiocmget_submit_urb(serial,
1523 serial->parent->usb);
1527 * next few functions largely stolen from drivers/serial/serial_core.c
1535 hso_wait_modem_status(struct hso_serial *serial, unsigned long arg)
1542 tiocmget = serial->tiocmget;
1548 spin_lock_irq(&serial->serial_lock);
1550 spin_unlock_irq(&serial->serial_lock);
1553 spin_lock_irq(&serial->serial_lock);
1555 spin_unlock_irq(&serial->serial_lock);
1578 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1587 struct hso_serial *serial = tty->driver_data;
1588 struct hso_tiocmget *tiocmget = serial->tiocmget;
1594 spin_lock_irq(&serial->serial_lock);
1596 spin_unlock_irq(&serial->serial_lock);
1617 struct hso_serial *serial = tty->driver_data;
1622 if (!serial) {
1626 spin_lock_irq(&serial->serial_lock);
1627 retval = ((serial->rts_state) ? TIOCM_RTS : 0) |
1628 ((serial->dtr_state) ? TIOCM_DTR : 0);
1629 tiocmget = serial->tiocmget;
1641 spin_unlock_irq(&serial->serial_lock);
1651 struct hso_serial *serial = tty->driver_data;
1655 if (!serial) {
1660 if ((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM)
1663 interface = serial->parent->interface;
1666 spin_lock_irqsave(&serial->serial_lock, flags);
1668 serial->rts_state = 1;
1670 serial->dtr_state = 1;
1673 serial->rts_state = 0;
1675 serial->dtr_state = 0;
1677 if (serial->dtr_state)
1679 if (serial->rts_state)
1682 spin_unlock_irqrestore(&serial->serial_lock, flags);
1684 return usb_control_msg(serial->parent->usb,
1685 usb_sndctrlpipe(serial->parent->usb, 0), 0x22,
1693 struct hso_serial *serial = tty->driver_data;
1697 if (!serial)
1701 ret = hso_wait_modem_status(serial, arg);
1712 static void hso_kick_transmit(struct hso_serial *serial)
1717 spin_lock_irqsave(&serial->serial_lock, flags);
1718 if (!serial->tx_buffer_count)
1721 if (serial->tx_urb_used)
1725 if (hso_get_activity(serial->parent) == -EAGAIN)
1729 swap(serial->tx_buffer, serial->tx_data);
1730 serial->tx_data_count = serial->tx_buffer_count;
1731 serial->tx_buffer_count = 0;
1733 /* If serial->tx_data is set, it means we switched buffers */
1734 if (serial->tx_data && serial->write_data) {
1735 res = serial->write_data(serial);
1737 serial->tx_urb_used = 1;
1740 spin_unlock_irqrestore(&serial->serial_lock, flags);
1743 /* make a request (for reading and writing data to muxed serial port) */
1744 static int mux_device_request(struct hso_serial *serial, u8 type, u16 port,
1753 if (!serial || !ctrl_urb || !ctrl_req) {
1769 pipe = usb_rcvctrlpipe(serial->parent->usb, 0);
1776 pipe = usb_sndctrlpipe(serial->parent->usb, 0);
1786 serial->parent->usb,
1789 ctrl_urb_data, size, ctrl_callback, serial);
1804 static int hso_mux_serial_read(struct hso_serial *serial)
1806 if (!serial)
1810 memset(serial->rx_data[0], 0, CTRL_URB_RX_SIZE);
1813 if (serial->num_rx_urbs != 1) {
1814 dev_err(&serial->parent->interface->dev,
1819 return mux_device_request(serial,
1821 serial->parent->port_spec & HSO_PORT_MASK,
1822 serial->rx_urb[0],
1823 &serial->ctrl_req_rx,
1824 serial->rx_data[0], serial->rx_data_length);
1827 /* used for muxed serial port callback (muxed serial read) */
1831 struct hso_serial *serial;
1857 serial = get_serial_by_shared_int_and_type(shared_int,
1859 if (serial != NULL) {
1862 spin_lock_irqsave(&serial->serial_lock, flags);
1863 if (serial->rx_state == RX_IDLE &&
1864 serial->port.count > 0) {
1867 if (!serial->rx_urb_filled[0]) {
1868 serial->rx_state = RX_SENT;
1869 hso_mux_serial_read(serial);
1871 serial->rx_state = RX_PENDING;
1876 spin_unlock_irqrestore(&serial->serial_lock,
1885 /* called for writing to muxed serial port */
1886 static int hso_mux_serial_write_data(struct hso_serial *serial)
1888 if (NULL == serial)
1891 return mux_device_request(serial,
1893 serial->parent->port_spec & HSO_PORT_MASK,
1894 serial->tx_urb,
1895 &serial->ctrl_req_tx,
1896 serial->tx_data, serial->tx_data_count);
1902 struct hso_serial *serial = urb->context;
1907 if (!serial) {
1908 hso_dbg(0x1, "serial == NULL\n");
1912 spin_lock_irqsave(&serial->serial_lock, flags);
1913 serial->tx_urb_used = 0;
1914 spin_unlock_irqrestore(&serial->serial_lock, flags);
1916 handle_usb_error(status, __func__, serial->parent);
1919 hso_put_activity(serial->parent);
1920 tty_port_tty_wakeup(&serial->port);
1921 hso_kick_transmit(serial);
1926 /* called for writing diag or CS serial port */
1927 static int hso_std_serial_write_data(struct hso_serial *serial)
1929 int count = serial->tx_data_count;
1932 usb_fill_bulk_urb(serial->tx_urb,
1933 serial->parent->usb,
1934 usb_sndbulkpipe(serial->parent->usb,
1935 serial->out_endp->
1937 serial->tx_data, serial->tx_data_count,
1938 hso_std_serial_write_bulk_callback, serial);
1940 result = usb_submit_urb(serial->tx_urb, GFP_ATOMIC);
1942 dev_warn(&serial->parent->usb->dev,
1950 /* callback after read or write on muxed serial port */
1953 struct hso_serial *serial = urb->context;
1959 if (!serial)
1962 spin_lock_irqsave(&serial->serial_lock, flags);
1963 serial->tx_urb_used = 0;
1964 spin_unlock_irqrestore(&serial->serial_lock, flags);
1966 handle_usb_error(status, __func__, serial->parent);
1979 serial->rx_urb_filled[0] = 1;
1980 spin_lock_irqsave(&serial->serial_lock, flags);
1981 put_rxbuf_data_and_resubmit_ctrl_urb(serial);
1982 spin_unlock_irqrestore(&serial->serial_lock, flags);
1984 hso_put_activity(serial->parent);
1985 tty_port_tty_wakeup(&serial->port);
1987 hso_kick_transmit(serial);
1991 /* handle RX data for serial port */
1992 static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial)
1998 if (urb == NULL || serial == NULL) {
1999 hso_dbg(0x1, "serial = NULL\n");
2003 tty = tty_port_tty_get(&serial->port);
2012 count = tty_buffer_request_room(&serial->port, urb->actual_length);
2014 tty_insert_flip_string(&serial->port, urb->transfer_buffer,
2016 tty_flip_buffer_push(&serial->port);
2018 dev_warn(&serial->parent->usb->dev,
2024 serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 0;
2137 struct hso_serial *serial = dev2ser(hso_dev);
2139 if (!serial)
2144 if (!(serial->parent->port_spec & HSO_INTF_MUX)) {
2145 for (i = 0; i < serial->num_rx_urbs; i++) {
2146 usb_fill_bulk_urb(serial->rx_urb[i],
2147 serial->parent->usb,
2148 usb_rcvbulkpipe(serial->parent->usb,
2149 serial->in_endp->
2152 serial->rx_data[i],
2153 serial->rx_data_length,
2155 serial);
2156 result = usb_submit_urb(serial->rx_urb[i], flags);
2158 dev_warn(&serial->parent->usb->dev,
2165 mutex_lock(&serial->shared_int->shared_int_lock);
2166 if (!serial->shared_int->use_count) {
2168 hso_mux_submit_intr_urb(serial->shared_int,
2171 serial->shared_int->use_count++;
2172 mutex_unlock(&serial->shared_int->shared_int_lock);
2174 if (serial->tiocmget)
2175 tiocmget_submit_urb(serial,
2176 serial->tiocmget,
2177 serial->parent->usb);
2184 struct hso_serial *serial = dev2ser(hso_dev);
2187 if (!serial)
2190 for (i = 0; i < serial->num_rx_urbs; i++) {
2191 if (serial->rx_urb[i]) {
2192 usb_kill_urb(serial->rx_urb[i]);
2193 serial->rx_urb_filled[i] = 0;
2196 serial->curr_rx_urb_idx = 0;
2198 if (serial->tx_urb)
2199 usb_kill_urb(serial->tx_urb);
2201 if (serial->shared_int) {
2202 mutex_lock(&serial->shared_int->shared_int_lock);
2203 if (serial->shared_int->use_count &&
2204 (--serial->shared_int->use_count == 0)) {
2207 urb = serial->shared_int->shared_intr_urb;
2211 mutex_unlock(&serial->shared_int->shared_int_lock);
2213 tiocmget = serial->tiocmget;
2222 static void hso_serial_tty_unregister(struct hso_serial *serial)
2224 tty_unregister_device(tty_drv, serial->minor);
2225 release_minor(serial);
2228 static void hso_serial_common_free(struct hso_serial *serial)
2232 for (i = 0; i < serial->num_rx_urbs; i++) {
2234 usb_free_urb(serial->rx_urb[i]);
2236 kfree(serial->rx_data[i]);
2240 usb_free_urb(serial->tx_urb);
2241 kfree(serial->tx_buffer);
2242 kfree(serial->tx_data);
2243 tty_port_destroy(&serial->port);
2246 static int hso_serial_common_create(struct hso_serial *serial, int num_urbs,
2251 tty_port_init(&serial->port);
2253 if (obtain_minor(serial))
2257 serial->parent->dev = tty_port_register_device_attr(&serial->port,
2258 tty_drv, serial->minor, &serial->parent->interface->dev,
2259 serial->parent, hso_serial_dev_groups);
2260 if (IS_ERR(serial->parent->dev)) {
2261 release_minor(serial);
2265 serial->magic = HSO_SERIAL_MAGIC;
2266 spin_lock_init(&serial->serial_lock);
2267 serial->num_rx_urbs = num_urbs;
2272 serial->rx_data_length = rx_size;
2273 for (i = 0; i < serial->num_rx_urbs; i++) {
2274 serial->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
2275 if (!serial->rx_urb[i])
2277 serial->rx_urb[i]->transfer_buffer = NULL;
2278 serial->rx_urb[i]->transfer_buffer_length = 0;
2279 serial->rx_data[i] = kzalloc(serial->rx_data_length,
2281 if (!serial->rx_data[i])
2286 serial->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
2287 if (!serial->tx_urb)
2289 serial->tx_urb->transfer_buffer = NULL;
2290 serial->tx_urb->transfer_buffer_length = 0;
2292 serial->tx_data_count = 0;
2293 serial->tx_buffer_count = 0;
2294 serial->tx_data_length = tx_size;
2295 serial->tx_data = kzalloc(serial->tx_data_length, GFP_KERNEL);
2296 if (!serial->tx_data)
2299 serial->tx_buffer = kzalloc(serial->tx_data_length, GFP_KERNEL);
2300 if (!serial->tx_buffer)
2305 hso_serial_tty_unregister(serial);
2307 hso_serial_common_free(serial);
2570 static void hso_free_tiomget(struct hso_serial *serial)
2573 if (!serial)
2575 tiocmget = serial->tiocmget;
2579 serial->tiocmget = NULL;
2589 struct hso_serial *serial = dev2ser(hso_dev);
2591 if (!serial)
2594 hso_serial_common_free(serial);
2596 if (serial->shared_int) {
2597 mutex_lock(&serial->shared_int->shared_int_lock);
2598 if (--serial->shared_int->ref_count == 0)
2599 hso_free_shared_int(serial->shared_int);
2601 mutex_unlock(&serial->shared_int->shared_int_lock);
2603 hso_free_tiomget(serial);
2604 kfree(serial);
2613 struct hso_serial *serial;
2621 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
2622 if (!serial)
2625 serial->parent = hso_dev;
2626 hso_dev->port_data.dev_serial = serial;
2630 serial->tiocmget = kzalloc(sizeof(struct hso_tiocmget),
2632 if (!serial->tiocmget)
2634 serial->tiocmget->serial_state_notification
2637 if (!serial->tiocmget->serial_state_notification)
2639 tiocmget = serial->tiocmget;
2658 if (hso_serial_common_create(serial, num_urbs, BULK_URB_RX_SIZE,
2662 serial->in_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,
2664 if (!serial->in_endp) {
2670 (serial->out_endp =
2676 serial->write_data = hso_std_serial_write_data;
2685 hso_serial_tty_unregister(serial);
2686 hso_serial_common_free(serial);
2688 hso_free_tiomget(serial);
2689 kfree(serial);
2701 struct hso_serial *serial;
2715 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
2716 if (!serial)
2719 hso_dev->port_data.dev_serial = serial;
2720 serial->parent = hso_dev;
2723 (serial, 1, CTRL_URB_RX_SIZE, CTRL_URB_TX_SIZE))
2726 serial->tx_data_length--;
2727 serial->write_data = hso_mux_serial_write_data;
2729 serial->shared_int = mux;
2730 mutex_lock(&serial->shared_int->shared_int_lock);
2731 serial->shared_int->ref_count++;
2732 mutex_unlock(&serial->shared_int->shared_int_lock);
2741 kfree(serial);
3023 /* Stop all serial ports */
3052 /* Start all serial ports */
3101 struct hso_serial *serial;
3107 serial = dev2ser(serial_table[i]);
3108 tty_port_tty_hangup(&serial->port, false);
3109 mutex_lock(&serial->parent->mutex);
3110 serial->parent->usb_gone = 1;
3111 mutex_unlock(&serial->parent->mutex);
3114 hso_serial_tty_unregister(serial);
3115 kref_put(&serial->parent->ref, hso_serial_ref_free);
3179 /* interrupt urb needs to be submitted, used for serial read of muxed port */
3201 /* operations setup of the serial interface */
3237 /* Initialise the serial table semaphore and table */