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);
368 /* serial structures */
515 static int hso_urb_to_index(struct hso_serial *serial, struct urb *urb)
519 for (idx = 0; idx < serial->num_rx_urbs; idx++)
520 if (serial->rx_urb[idx] == urb)
522 dev_err(serial->parent->dev, "hso_urb_to_index failed\n");
601 struct hso_serial *serial = NULL;
606 serial = dev2ser(serial_table[index]);
609 return serial;
612 static int obtain_minor(struct hso_serial *serial)
620 serial_table[index] = serial->parent;
621 serial->minor = index;
628 pr_err("%s: no free serial devices in table\n", __func__);
632 static void release_minor(struct hso_serial *serial)
637 serial_table[serial->minor] = NULL;
1083 struct hso_serial *serial = tty->driver_data;
1085 if (!serial) {
1090 hso_dbg(0x8, "port %d\n", serial->minor);
1109 static void hso_resubmit_rx_bulk_urb(struct hso_serial *serial, struct urb *urb)
1114 usb_fill_bulk_urb(urb, serial->parent->usb,
1115 usb_rcvbulkpipe(serial->parent->usb,
1116 serial->in_endp->
1118 urb->transfer_buffer, serial->rx_data_length,
1119 hso_std_serial_read_bulk_callback, serial);
1124 dev_err(&urb->dev->dev, "%s failed submit serial rx_urb %d\n",
1132 static void put_rxbuf_data_and_resubmit_bulk_urb(struct hso_serial *serial)
1137 while (serial->rx_urb_filled[serial->curr_rx_urb_idx]) {
1138 curr_urb = serial->rx_urb[serial->curr_rx_urb_idx];
1139 count = put_rxbuf_data(curr_urb, serial);
1143 serial->curr_rx_urb_idx++;
1144 if (serial->curr_rx_urb_idx >= serial->num_rx_urbs)
1145 serial->curr_rx_urb_idx = 0;
1146 hso_resubmit_rx_bulk_urb(serial, curr_urb);
1151 static void put_rxbuf_data_and_resubmit_ctrl_urb(struct hso_serial *serial)
1156 urb = serial->rx_urb[0];
1157 if (serial->port.count > 0) {
1158 count = put_rxbuf_data(urb, serial);
1165 (serial->rx_state == RX_PENDING))) {
1166 serial->rx_state = RX_SENT;
1167 hso_mux_serial_read(serial);
1169 serial->rx_state = RX_IDLE;
1176 struct hso_serial *serial = urb->context;
1183 if (!serial) {
1184 hso_dbg(0x1, "serial == NULL\n");
1188 handle_usb_error(status, __func__, serial->parent);
1196 if (serial->port.count == 0)
1199 if (serial->parent->port_spec & HSO_INFO_CRC_BUG)
1200 fix_crc_bug(urb, serial->in_endp->wMaxPacketSize);
1202 spin_lock_irqsave(&serial->serial_lock, flags);
1203 serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 1;
1204 put_rxbuf_data_and_resubmit_bulk_urb(serial);
1205 spin_unlock_irqrestore(&serial->serial_lock, flags);
1214 struct hso_serial *serial = from_tasklet(serial, t,
1218 spin_lock_irqsave(&serial->serial_lock, flags);
1219 if ((serial->parent->port_spec & HSO_INTF_MUX))
1220 put_rxbuf_data_and_resubmit_ctrl_urb(serial);
1222 put_rxbuf_data_and_resubmit_bulk_urb(serial);
1223 spin_unlock_irqrestore(&serial->serial_lock, flags);
1228 struct hso_serial *serial = tty->driver_data;
1230 tasklet_hi_schedule(&serial->unthrottle_tasklet);
1233 /* open the requested serial port */
1236 struct hso_serial *serial = get_serial_by_index(tty->index);
1240 if (serial == NULL || serial->magic != HSO_SERIAL_MAGIC) {
1247 mutex_lock(&serial->parent->mutex);
1248 result = usb_autopm_get_interface(serial->parent->interface);
1252 hso_dbg(0x1, "Opening %d\n", serial->minor);
1255 tty->driver_data = serial;
1256 tty_port_tty_set(&serial->port, tty);
1259 serial->port.count++;
1260 if (serial->port.count == 1) {
1261 serial->rx_state = RX_IDLE;
1264 tasklet_setup(&serial->unthrottle_tasklet,
1266 result = hso_start_serial_device(serial->parent, GFP_KERNEL);
1268 hso_stop_serial_device(serial->parent);
1269 serial->port.count--;
1271 kref_get(&serial->parent->ref);
1277 usb_autopm_put_interface(serial->parent->interface);
1283 mutex_unlock(&serial->parent->mutex);
1287 /* close the requested serial port */
1290 struct hso_serial *serial = tty->driver_data;
1293 hso_dbg(0x1, "Closing serial port\n");
1296 if (serial == NULL)
1299 mutex_lock(&serial->parent->mutex);
1300 usb_gone = serial->parent->usb_gone;
1303 usb_autopm_get_interface(serial->parent->interface);
1307 serial->port.count--;
1309 if (serial->port.count <= 0) {
1310 serial->port.count = 0;
1311 tty_port_tty_set(&serial->port, NULL);
1313 hso_stop_serial_device(serial->parent);
1314 tasklet_kill(&serial->unthrottle_tasklet);
1318 usb_autopm_put_interface(serial->parent->interface);
1320 mutex_unlock(&serial->parent->mutex);
1323 /* close the requested serial port */
1327 struct hso_serial *serial = tty->driver_data;
1331 if (serial == NULL) {
1332 pr_err("%s: serial is NULL\n", __func__);
1336 spin_lock_irqsave(&serial->serial_lock, flags);
1338 count = min_t(size_t, serial->tx_data_length - serial->tx_buffer_count,
1340 memcpy(serial->tx_buffer + serial->tx_buffer_count, buf, count);
1341 serial->tx_buffer_count += count;
1343 spin_unlock_irqrestore(&serial->serial_lock, flags);
1345 hso_kick_transmit(serial);
1353 struct hso_serial *serial = tty->driver_data;
1357 spin_lock_irqsave(&serial->serial_lock, flags);
1358 room = serial->tx_data_length - serial->tx_buffer_count;
1359 spin_unlock_irqrestore(&serial->serial_lock, flags);
1367 struct hso_serial *serial = tty->driver_data;
1369 if (!serial)
1372 kref_put(&serial->parent->ref, hso_serial_ref_free);
1379 struct hso_serial *serial = tty->driver_data;
1388 spin_lock_irqsave(&serial->serial_lock, flags);
1389 if (serial->port.count)
1393 spin_unlock_irqrestore(&serial->serial_lock, flags);
1401 struct hso_serial *serial = tty->driver_data;
1406 if (serial == NULL)
1409 spin_lock_irqsave(&serial->serial_lock, flags);
1410 chars = serial->tx_buffer_count;
1411 spin_unlock_irqrestore(&serial->serial_lock, flags);
1415 static int tiocmget_submit_urb(struct hso_serial *serial,
1421 if (serial->parent->usb_gone)
1429 tiocmget_intr_callback, serial,
1442 struct hso_serial *serial = urb->context;
1453 if (!serial)
1456 handle_usb_error(status, __func__, serial->parent);
1461 tiocmget = serial->tiocmget;
1464 BUG_ON((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM);
1466 usb = serial->parent->usb;
1467 interface = serial->parent->interface;
1481 "hso received invalid serial state notification\n");
1491 spin_lock_irqsave(&serial->serial_lock, flags);
1514 spin_unlock_irqrestore(&serial->serial_lock, flags);
1520 tiocmget_submit_urb(serial,
1522 serial->parent->usb);
1526 * next few functions largely stolen from drivers/serial/serial_core.c
1534 hso_wait_modem_status(struct hso_serial *serial, unsigned long arg)
1541 tiocmget = serial->tiocmget;
1547 spin_lock_irq(&serial->serial_lock);
1549 spin_unlock_irq(&serial->serial_lock);
1552 spin_lock_irq(&serial->serial_lock);
1554 spin_unlock_irq(&serial->serial_lock);
1577 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1586 struct hso_serial *serial = tty->driver_data;
1587 struct hso_tiocmget *tiocmget = serial->tiocmget;
1593 spin_lock_irq(&serial->serial_lock);
1595 spin_unlock_irq(&serial->serial_lock);
1616 struct hso_serial *serial = tty->driver_data;
1621 if (!serial) {
1625 spin_lock_irq(&serial->serial_lock);
1626 retval = ((serial->rts_state) ? TIOCM_RTS : 0) |
1627 ((serial->dtr_state) ? TIOCM_DTR : 0);
1628 tiocmget = serial->tiocmget;
1640 spin_unlock_irq(&serial->serial_lock);
1650 struct hso_serial *serial = tty->driver_data;
1654 if (!serial) {
1659 if ((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM)
1662 interface = serial->parent->interface;
1665 spin_lock_irqsave(&serial->serial_lock, flags);
1667 serial->rts_state = 1;
1669 serial->dtr_state = 1;
1672 serial->rts_state = 0;
1674 serial->dtr_state = 0;
1676 if (serial->dtr_state)
1678 if (serial->rts_state)
1681 spin_unlock_irqrestore(&serial->serial_lock, flags);
1683 return usb_control_msg(serial->parent->usb,
1684 usb_sndctrlpipe(serial->parent->usb, 0), 0x22,
1692 struct hso_serial *serial = tty->driver_data;
1696 if (!serial)
1700 ret = hso_wait_modem_status(serial, arg);
1711 static void hso_kick_transmit(struct hso_serial *serial)
1716 spin_lock_irqsave(&serial->serial_lock, flags);
1717 if (!serial->tx_buffer_count)
1720 if (serial->tx_urb_used)
1724 if (hso_get_activity(serial->parent) == -EAGAIN)
1728 swap(serial->tx_buffer, serial->tx_data);
1729 serial->tx_data_count = serial->tx_buffer_count;
1730 serial->tx_buffer_count = 0;
1732 /* If serial->tx_data is set, it means we switched buffers */
1733 if (serial->tx_data && serial->write_data) {
1734 res = serial->write_data(serial);
1736 serial->tx_urb_used = 1;
1739 spin_unlock_irqrestore(&serial->serial_lock, flags);
1742 /* make a request (for reading and writing data to muxed serial port) */
1743 static int mux_device_request(struct hso_serial *serial, u8 type, u16 port,
1752 if (!serial || !ctrl_urb || !ctrl_req) {
1768 pipe = usb_rcvctrlpipe(serial->parent->usb, 0);
1775 pipe = usb_sndctrlpipe(serial->parent->usb, 0);
1785 serial->parent->usb,
1788 ctrl_urb_data, size, ctrl_callback, serial);
1803 static int hso_mux_serial_read(struct hso_serial *serial)
1805 if (!serial)
1809 memset(serial->rx_data[0], 0, CTRL_URB_RX_SIZE);
1812 if (serial->num_rx_urbs != 1) {
1813 dev_err(&serial->parent->interface->dev,
1818 return mux_device_request(serial,
1820 serial->parent->port_spec & HSO_PORT_MASK,
1821 serial->rx_urb[0],
1822 &serial->ctrl_req_rx,
1823 serial->rx_data[0], serial->rx_data_length);
1826 /* used for muxed serial port callback (muxed serial read) */
1830 struct hso_serial *serial;
1856 serial = get_serial_by_shared_int_and_type(shared_int,
1858 if (serial != NULL) {
1861 spin_lock_irqsave(&serial->serial_lock, flags);
1862 if (serial->rx_state == RX_IDLE &&
1863 serial->port.count > 0) {
1866 if (!serial->rx_urb_filled[0]) {
1867 serial->rx_state = RX_SENT;
1868 hso_mux_serial_read(serial);
1870 serial->rx_state = RX_PENDING;
1875 spin_unlock_irqrestore(&serial->serial_lock,
1884 /* called for writing to muxed serial port */
1885 static int hso_mux_serial_write_data(struct hso_serial *serial)
1887 if (NULL == serial)
1890 return mux_device_request(serial,
1892 serial->parent->port_spec & HSO_PORT_MASK,
1893 serial->tx_urb,
1894 &serial->ctrl_req_tx,
1895 serial->tx_data, serial->tx_data_count);
1901 struct hso_serial *serial = urb->context;
1906 if (!serial) {
1907 hso_dbg(0x1, "serial == NULL\n");
1911 spin_lock_irqsave(&serial->serial_lock, flags);
1912 serial->tx_urb_used = 0;
1913 spin_unlock_irqrestore(&serial->serial_lock, flags);
1915 handle_usb_error(status, __func__, serial->parent);
1918 hso_put_activity(serial->parent);
1919 tty_port_tty_wakeup(&serial->port);
1920 hso_kick_transmit(serial);
1925 /* called for writing diag or CS serial port */
1926 static int hso_std_serial_write_data(struct hso_serial *serial)
1928 int count = serial->tx_data_count;
1931 usb_fill_bulk_urb(serial->tx_urb,
1932 serial->parent->usb,
1933 usb_sndbulkpipe(serial->parent->usb,
1934 serial->out_endp->
1936 serial->tx_data, serial->tx_data_count,
1937 hso_std_serial_write_bulk_callback, serial);
1939 result = usb_submit_urb(serial->tx_urb, GFP_ATOMIC);
1941 dev_warn(&serial->parent->usb->dev,
1949 /* callback after read or write on muxed serial port */
1952 struct hso_serial *serial = urb->context;
1958 if (!serial)
1961 spin_lock_irqsave(&serial->serial_lock, flags);
1962 serial->tx_urb_used = 0;
1963 spin_unlock_irqrestore(&serial->serial_lock, flags);
1965 handle_usb_error(status, __func__, serial->parent);
1978 serial->rx_urb_filled[0] = 1;
1979 spin_lock_irqsave(&serial->serial_lock, flags);
1980 put_rxbuf_data_and_resubmit_ctrl_urb(serial);
1981 spin_unlock_irqrestore(&serial->serial_lock, flags);
1983 hso_put_activity(serial->parent);
1984 tty_port_tty_wakeup(&serial->port);
1986 hso_kick_transmit(serial);
1990 /* handle RX data for serial port */
1991 static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial)
1997 if (urb == NULL || serial == NULL) {
1998 hso_dbg(0x1, "serial = NULL\n");
2002 tty = tty_port_tty_get(&serial->port);
2011 count = tty_buffer_request_room(&serial->port, urb->actual_length);
2013 tty_insert_flip_string(&serial->port, urb->transfer_buffer,
2015 tty_flip_buffer_push(&serial->port);
2017 dev_warn(&serial->parent->usb->dev,
2023 serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 0;
2136 struct hso_serial *serial = dev2ser(hso_dev);
2138 if (!serial)
2143 if (!(serial->parent->port_spec & HSO_INTF_MUX)) {
2144 for (i = 0; i < serial->num_rx_urbs; i++) {
2145 usb_fill_bulk_urb(serial->rx_urb[i],
2146 serial->parent->usb,
2147 usb_rcvbulkpipe(serial->parent->usb,
2148 serial->in_endp->
2151 serial->rx_data[i],
2152 serial->rx_data_length,
2154 serial);
2155 result = usb_submit_urb(serial->rx_urb[i], flags);
2157 dev_warn(&serial->parent->usb->dev,
2164 mutex_lock(&serial->shared_int->shared_int_lock);
2165 if (!serial->shared_int->use_count) {
2167 hso_mux_submit_intr_urb(serial->shared_int,
2170 serial->shared_int->use_count++;
2171 mutex_unlock(&serial->shared_int->shared_int_lock);
2173 if (serial->tiocmget)
2174 tiocmget_submit_urb(serial,
2175 serial->tiocmget,
2176 serial->parent->usb);
2183 struct hso_serial *serial = dev2ser(hso_dev);
2186 if (!serial)
2189 for (i = 0; i < serial->num_rx_urbs; i++) {
2190 if (serial->rx_urb[i]) {
2191 usb_kill_urb(serial->rx_urb[i]);
2192 serial->rx_urb_filled[i] = 0;
2195 serial->curr_rx_urb_idx = 0;
2197 if (serial->tx_urb)
2198 usb_kill_urb(serial->tx_urb);
2200 if (serial->shared_int) {
2201 mutex_lock(&serial->shared_int->shared_int_lock);
2202 if (serial->shared_int->use_count &&
2203 (--serial->shared_int->use_count == 0)) {
2206 urb = serial->shared_int->shared_intr_urb;
2210 mutex_unlock(&serial->shared_int->shared_int_lock);
2212 tiocmget = serial->tiocmget;
2221 static void hso_serial_tty_unregister(struct hso_serial *serial)
2223 tty_unregister_device(tty_drv, serial->minor);
2224 release_minor(serial);
2227 static void hso_serial_common_free(struct hso_serial *serial)
2231 for (i = 0; i < serial->num_rx_urbs; i++) {
2233 usb_free_urb(serial->rx_urb[i]);
2235 kfree(serial->rx_data[i]);
2239 usb_free_urb(serial->tx_urb);
2240 kfree(serial->tx_buffer);
2241 kfree(serial->tx_data);
2242 tty_port_destroy(&serial->port);
2245 static int hso_serial_common_create(struct hso_serial *serial, int num_urbs,
2250 tty_port_init(&serial->port);
2252 if (obtain_minor(serial))
2256 serial->parent->dev = tty_port_register_device_attr(&serial->port,
2257 tty_drv, serial->minor, &serial->parent->interface->dev,
2258 serial->parent, hso_serial_dev_groups);
2259 if (IS_ERR(serial->parent->dev)) {
2260 release_minor(serial);
2264 serial->magic = HSO_SERIAL_MAGIC;
2265 spin_lock_init(&serial->serial_lock);
2266 serial->num_rx_urbs = num_urbs;
2271 serial->rx_data_length = rx_size;
2272 for (i = 0; i < serial->num_rx_urbs; i++) {
2273 serial->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
2274 if (!serial->rx_urb[i])
2276 serial->rx_urb[i]->transfer_buffer = NULL;
2277 serial->rx_urb[i]->transfer_buffer_length = 0;
2278 serial->rx_data[i] = kzalloc(serial->rx_data_length,
2280 if (!serial->rx_data[i])
2285 serial->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
2286 if (!serial->tx_urb)
2288 serial->tx_urb->transfer_buffer = NULL;
2289 serial->tx_urb->transfer_buffer_length = 0;
2291 serial->tx_data_count = 0;
2292 serial->tx_buffer_count = 0;
2293 serial->tx_data_length = tx_size;
2294 serial->tx_data = kzalloc(serial->tx_data_length, GFP_KERNEL);
2295 if (!serial->tx_data)
2298 serial->tx_buffer = kzalloc(serial->tx_data_length, GFP_KERNEL);
2299 if (!serial->tx_buffer)
2304 hso_serial_tty_unregister(serial);
2306 hso_serial_common_free(serial);
2569 static void hso_free_tiomget(struct hso_serial *serial)
2572 if (!serial)
2574 tiocmget = serial->tiocmget;
2578 serial->tiocmget = NULL;
2588 struct hso_serial *serial = dev2ser(hso_dev);
2590 if (!serial)
2593 hso_serial_common_free(serial);
2595 if (serial->shared_int) {
2596 mutex_lock(&serial->shared_int->shared_int_lock);
2597 if (--serial->shared_int->ref_count == 0)
2598 hso_free_shared_int(serial->shared_int);
2600 mutex_unlock(&serial->shared_int->shared_int_lock);
2602 hso_free_tiomget(serial);
2603 kfree(serial);
2612 struct hso_serial *serial;
2620 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
2621 if (!serial)
2624 serial->parent = hso_dev;
2625 hso_dev->port_data.dev_serial = serial;
2629 serial->tiocmget = kzalloc(sizeof(struct hso_tiocmget),
2631 if (!serial->tiocmget)
2633 serial->tiocmget->serial_state_notification
2636 if (!serial->tiocmget->serial_state_notification)
2638 tiocmget = serial->tiocmget;
2657 if (hso_serial_common_create(serial, num_urbs, BULK_URB_RX_SIZE,
2661 serial->in_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,
2663 if (!serial->in_endp) {
2669 (serial->out_endp =
2675 serial->write_data = hso_std_serial_write_data;
2684 hso_serial_tty_unregister(serial);
2685 hso_serial_common_free(serial);
2687 hso_free_tiomget(serial);
2688 kfree(serial);
2700 struct hso_serial *serial;
2714 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
2715 if (!serial)
2718 hso_dev->port_data.dev_serial = serial;
2719 serial->parent = hso_dev;
2722 (serial, 1, CTRL_URB_RX_SIZE, CTRL_URB_TX_SIZE))
2725 serial->tx_data_length--;
2726 serial->write_data = hso_mux_serial_write_data;
2728 serial->shared_int = mux;
2729 mutex_lock(&serial->shared_int->shared_int_lock);
2730 serial->shared_int->ref_count++;
2731 mutex_unlock(&serial->shared_int->shared_int_lock);
2740 kfree(serial);
3022 /* Stop all serial ports */
3051 /* Start all serial ports */
3100 struct hso_serial *serial;
3106 serial = dev2ser(serial_table[i]);
3107 tty_port_tty_hangup(&serial->port, false);
3108 mutex_lock(&serial->parent->mutex);
3109 serial->parent->usb_gone = 1;
3110 mutex_unlock(&serial->parent->mutex);
3113 hso_serial_tty_unregister(serial);
3114 kref_put(&serial->parent->ref, hso_serial_ref_free);
3178 /* interrupt urb needs to be submitted, used for serial read of muxed port */
3200 /* operations setup of the serial interface */