Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/tty/serial/jsm/jsm_driver.c

  1 /************************************************************************
  2  * Copyright 2003 Digi International (www.digi.com)
  3  *
  4  * Copyright (C) 2004 IBM Corporation. All rights reserved.
  5  *
  6  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License as published by
  8  * the Free Software Foundation; either version 2, or (at your option)
  9  * any later version.
 10  *
 11  * This program is distributed in the hope that it will be useful,
 12  * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the
 13  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 14  * PURPOSE.  See the GNU General Public License for more details.
 15  *
 16  * You should have received a copy of the GNU General Public License
 17  * along with this program; if not, write to the Free Software
 18  * Foundation, Inc., 59 * Temple Place - Suite 330, Boston,
 19  * MA  02111-1307, USA.
 20  *
 21  * Contact Information:
 22  * Scott H Kilau <Scott_Kilau@digi.com>
 23  * Wendy Xiong   <wendyx@us.ibm.com>
 24  *
 25  *
 26  ***********************************************************************/
 27 #include <linux/module.h>
 28 #include <linux/pci.h>
 29 #include <linux/slab.h>
 30 
 31 #include "jsm.h"
 32 
 33 MODULE_AUTHOR("Digi International, http://www.digi.com");
 34 MODULE_DESCRIPTION("Driver for the Digi International "
 35                    "Neo PCI based product line");
 36 MODULE_LICENSE("GPL");
 37 MODULE_SUPPORTED_DEVICE("jsm");
 38 
 39 #define JSM_DRIVER_NAME "jsm"
 40 #define NR_PORTS        32
 41 #define JSM_MINOR_START 0
 42 
 43 struct uart_driver jsm_uart_driver = {
 44         .owner          = THIS_MODULE,
 45         .driver_name    = JSM_DRIVER_NAME,
 46         .dev_name       = "ttyn",
 47         .major          = 0,
 48         .minor          = JSM_MINOR_START,
 49         .nr             = NR_PORTS,
 50 };
 51 
 52 static pci_ers_result_t jsm_io_error_detected(struct pci_dev *pdev,
 53                                        pci_channel_state_t state);
 54 static pci_ers_result_t jsm_io_slot_reset(struct pci_dev *pdev);
 55 static void jsm_io_resume(struct pci_dev *pdev);
 56 
 57 static const struct pci_error_handlers jsm_err_handler = {
 58         .error_detected = jsm_io_error_detected,
 59         .slot_reset = jsm_io_slot_reset,
 60         .resume = jsm_io_resume,
 61 };
 62 
 63 int jsm_debug;
 64 module_param(jsm_debug, int, 0);
 65 MODULE_PARM_DESC(jsm_debug, "Driver debugging level");
 66 
 67 static int jsm_probe_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 68 {
 69         int rc = 0;
 70         struct jsm_board *brd;
 71         static int adapter_count = 0;
 72 
 73         rc = pci_enable_device(pdev);
 74         if (rc) {
 75                 dev_err(&pdev->dev, "Device enable FAILED\n");
 76                 goto out;
 77         }
 78 
 79         rc = pci_request_regions(pdev, "jsm");
 80         if (rc) {
 81                 dev_err(&pdev->dev, "pci_request_region FAILED\n");
 82                 goto out_disable_device;
 83         }
 84 
 85         brd = kzalloc(sizeof(struct jsm_board), GFP_KERNEL);
 86         if (!brd) {
 87                 dev_err(&pdev->dev,
 88                         "memory allocation for board structure failed\n");
 89                 rc = -ENOMEM;
 90                 goto out_release_regions;
 91         }
 92 
 93         /* store the info for the board we've found */
 94         brd->boardnum = adapter_count++;
 95         brd->pci_dev = pdev;
 96         if (pdev->device == PCIE_DEVICE_ID_NEO_4_IBM)
 97                 brd->maxports = 4;
 98         else if (pdev->device == PCI_DEVICE_ID_DIGI_NEO_8)
 99                 brd->maxports = 8;
100         else
101                 brd->maxports = 2;
102 
103         spin_lock_init(&brd->bd_intr_lock);
104 
105         /* store which revision we have */
106         brd->rev = pdev->revision;
107 
108         brd->irq = pdev->irq;
109 
110         jsm_dbg(INIT, &brd->pci_dev, "jsm_found_board - NEO adapter\n");
111 
112         /* get the PCI Base Address Registers */
113         brd->membase    = pci_resource_start(pdev, 0);
114         brd->membase_end = pci_resource_end(pdev, 0);
115 
116         if (brd->membase & 1)
117                 brd->membase &= ~3;
118         else
119                 brd->membase &= ~15;
120 
121         /* Assign the board_ops struct */
122         brd->bd_ops = &jsm_neo_ops;
123 
124         brd->bd_uart_offset = 0x200;
125         brd->bd_dividend = 921600;
126 
127         brd->re_map_membase = ioremap(brd->membase, pci_resource_len(pdev, 0));
128         if (!brd->re_map_membase) {
129                 dev_err(&pdev->dev,
130                         "card has no PCI Memory resources, "
131                         "failing board.\n");
132                 rc = -ENOMEM;
133                 goto out_kfree_brd;
134         }
135 
136         rc = request_irq(brd->irq, brd->bd_ops->intr,
137                         IRQF_SHARED, "JSM", brd);
138         if (rc) {
139                 printk(KERN_WARNING "Failed to hook IRQ %d\n",brd->irq);
140                 goto out_iounmap;
141         }
142 
143         rc = jsm_tty_init(brd);
144         if (rc < 0) {
145                 dev_err(&pdev->dev, "Can't init tty devices (%d)\n", rc);
146                 rc = -ENXIO;
147                 goto out_free_irq;
148         }
149 
150         rc = jsm_uart_port_init(brd);
151         if (rc < 0) {
152                 /* XXX: leaking all resources from jsm_tty_init here! */
153                 dev_err(&pdev->dev, "Can't init uart port (%d)\n", rc);
154                 rc = -ENXIO;
155                 goto out_free_irq;
156         }
157 
158         /* Log the information about the board */
159         dev_info(&pdev->dev, "board %d: Digi Neo (rev %d), irq %d\n",
160                         adapter_count, brd->rev, brd->irq);
161 
162         pci_set_drvdata(pdev, brd);
163         pci_save_state(pdev);
164 
165         return 0;
166  out_free_irq:
167         jsm_remove_uart_port(brd);
168         free_irq(brd->irq, brd);
169  out_iounmap:
170         iounmap(brd->re_map_membase);
171  out_kfree_brd:
172         kfree(brd);
173  out_release_regions:
174         pci_release_regions(pdev);
175  out_disable_device:
176         pci_disable_device(pdev);
177  out:
178         return rc;
179 }
180 
181 static void jsm_remove_one(struct pci_dev *pdev)
182 {
183         struct jsm_board *brd = pci_get_drvdata(pdev);
184         int i = 0;
185 
186         jsm_remove_uart_port(brd);
187 
188         free_irq(brd->irq, brd);
189         iounmap(brd->re_map_membase);
190 
191         /* Free all allocated channels structs */
192         for (i = 0; i < brd->maxports; i++) {
193                 if (brd->channels[i]) {
194                         kfree(brd->channels[i]->ch_rqueue);
195                         kfree(brd->channels[i]->ch_equeue);
196                         kfree(brd->channels[i]);
197                 }
198         }
199 
200         pci_release_regions(pdev);
201         pci_disable_device(pdev);
202         kfree(brd);
203 }
204 
205 static struct pci_device_id jsm_pci_tbl[] = {
206         { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2DB9), 0, 0, 0 },
207         { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2DB9PRI), 0, 0, 1 },
208         { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2RJ45), 0, 0, 2 },
209         { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2RJ45PRI), 0, 0, 3 },
210         { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCIE_DEVICE_ID_NEO_4_IBM), 0, 0, 4 },
211         { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_DIGI_NEO_8), 0, 0, 5 },
212         { 0, }
213 };
214 MODULE_DEVICE_TABLE(pci, jsm_pci_tbl);
215 
216 static struct pci_driver jsm_driver = {
217         .name           = "jsm",
218         .id_table       = jsm_pci_tbl,
219         .probe          = jsm_probe_one,
220         .remove         = jsm_remove_one,
221         .err_handler    = &jsm_err_handler,
222 };
223 
224 static pci_ers_result_t jsm_io_error_detected(struct pci_dev *pdev,
225                                         pci_channel_state_t state)
226 {
227         struct jsm_board *brd = pci_get_drvdata(pdev);
228 
229         jsm_remove_uart_port(brd);
230 
231         return PCI_ERS_RESULT_NEED_RESET;
232 }
233 
234 static pci_ers_result_t jsm_io_slot_reset(struct pci_dev *pdev)
235 {
236         int rc;
237 
238         rc = pci_enable_device(pdev);
239 
240         if (rc)
241                 return PCI_ERS_RESULT_DISCONNECT;
242 
243         pci_set_master(pdev);
244 
245         return PCI_ERS_RESULT_RECOVERED;
246 }
247 
248 static void jsm_io_resume(struct pci_dev *pdev)
249 {
250         struct jsm_board *brd = pci_get_drvdata(pdev);
251 
252         pci_restore_state(pdev);
253         pci_save_state(pdev);
254 
255         jsm_uart_port_init(brd);
256 }
257 
258 static int __init jsm_init_module(void)
259 {
260         int rc;
261 
262         rc = uart_register_driver(&jsm_uart_driver);
263         if (!rc) {
264                 rc = pci_register_driver(&jsm_driver);
265                 if (rc)
266                         uart_unregister_driver(&jsm_uart_driver);
267         }
268         return rc;
269 }
270 
271 static void __exit jsm_exit_module(void)
272 {
273         pci_unregister_driver(&jsm_driver);
274         uart_unregister_driver(&jsm_uart_driver);
275 }
276 
277 module_init(jsm_init_module);
278 module_exit(jsm_exit_module);
279 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us