2 * Linux CAN-bus device driver.
3 * Written by Jan Kriz email:johen@post.cz
4 * This software is released under the GPL-License.
5 * Version lincan-0.3 17 Jun 2004
8 * USB Skeleton driver - 2.2
10 * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com)
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License as
14 * published by the Free Software Foundation, version 2.
16 * This driver is based on the 2.6.3 version of drivers/usb/usb-skeleton.c
17 * but has been rewritten to be easier to read and use.
21 #include "./can/can.h"
22 #include "./can/can_sysdep.h"
23 #include "./can/main.h"
24 #include "./can/devcommon.h"
25 #include "./can/setup.h"
26 // #include "./can/finish.h"
27 #include "./can/i82527.h"
28 //#include "../include/sja1000.h"
29 #include "./can/sja1000p.h"
31 #include "./can/errno.h"
33 #include "./can/ul_usb1.h"
35 /* Get a minor range for your devices from the usb maintainer */
36 #define USB_SKEL_MINOR_BASE 192
38 #define CAN_OP_MASK 0x80
39 #define CAN_OP_READ 0x80
40 #define CAN_OP_WRITE 0x00
43 /* our private defines. if this grows any larger, use your own .h file */
44 #define MAX_TRANSFER (PAGE_SIZE - 512)
45 /* MAX_TRANSFER is chosen so that the VM is not stressed by
46 allocations > PAGE_SIZE and the number of packets in a page
47 is an integer 512 is the largest possible packet on EHCI */
48 #define WRITES_IN_FLIGHT 8
49 /* arbitrarily chosen */
51 /* Define these values to match your devices */
52 #define USB_SKEL_VENDOR_ID 0xDEAD
53 #define USB_SKEL_PRODUCT_ID 0x1001
55 /* table of devices that work with this driver */
56 // static struct usb_device_id ul_usb1_table [] = {
57 // { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
58 // { } /* Terminating entry */
60 // MODULE_DEVICE_TABLE(usb, ul_usb1_table);
62 // extern struct file_operations can_fops;
64 // struct ul_usb1_combo {
65 // struct usb_ul_usb1 * dev;
70 * IO_RANGE is the io-memory range that gets reserved, please adjust according
71 * your hardware. Example: #define IO_RANGE 0x100 for i82527 chips or
72 * #define IO_RANGE 0x20 for sja1000 chips in basic CAN mode.
74 #define IO_RANGE 0x100
76 /** ul_usb1_request_io
77 * ul_usb1_request_io: - reserve io or memory range for can board
78 * @candev: pointer to candevice/board which asks for io. Field @io_addr
79 * of @candev is used in most cases to define start of the range
81 * The function ul_usb1_request_io() is used to reserve the io-memory. If your
82 * hardware uses a dedicated memory range as hardware control registers you
83 * will have to add the code to reserve this memory as well.
84 * %IO_RANGE is the io-memory range that gets reserved, please adjust according
85 * your hardware. Example: #define IO_RANGE 0x100 for i82527 chips or
86 * #define IO_RANGE 0x20 for sja1000 chips in basic CAN mode.
87 * Return Value: The function returns zero on success or %-ENODEV on failure
90 int ul_usb1_request_io(struct candevice_t *candev)
92 // ((struct usb_ul_usb1*)candev->sysdevptr.anydev)->candev=candev;
96 /** ul_usb1_release_io
97 * ul_usb1_release_io - free reserved io memory range
98 * @candev: pointer to candevice/board which releases io
100 * The function ul_usb1_release_io() is used to free reserved io-memory.
101 * In case you have reserved more io memory, don't forget to free it here.
102 * IO_RANGE is the io-memory range that gets released, please adjust according
103 * your hardware. Example: #define IO_RANGE 0x100 for i82527 chips or
104 * #define IO_RANGE 0x20 for sja1000 chips in basic CAN mode.
105 * Return Value: The function always returns zero
106 * File: src/ul_usb1.c
108 int ul_usb1_release_io(struct candevice_t *candev)
110 /* struct usb_ul_usb1 *dev;
111 if (candev->sysdevptr.anydev){
112 dev=(struct usb_ul_usb1*) candev->sysdevptr.anydev;
113 usb_put_dev(dev->udev);
114 usb_kill_urb(dev->irq);
115 usb_free_urb(dev->irq);
116 kfree(dev->bulk_in_buffer);
117 kfree(dev->int_in_buffer);
119 dev->candev->sysdevptr.anydev=NULL;
120 //cleanup_usbdev(dev->candev);
128 * ul_usb1_reset - hardware reset routine
129 * @candev: Pointer to candevice/board structure
131 * The function ul_usb1_reset() is used to give a hardware reset. This is
132 * rather hardware specific so I haven't included example code. Don't forget to
133 * check the reset status of the chip before returning.
134 * Return Value: The function returns zero on success or %-ENODEV on failure
135 * File: src/ul_usb1.c
137 int ul_usb1_reset(struct candevice_t *candev)
142 #define RESET_ADDR 0x0
146 /** ul_usb1_init_hw_data
147 * ul_usb1_init_hw_data - Initialize hardware cards
148 * @candev: Pointer to candevice/board structure
150 * The function ul_usb1_init_hw_data() is used to initialize the hardware
151 * structure containing information about the installed CAN-board.
152 * %RESET_ADDR represents the io-address of the hardware reset register.
153 * %NR_82527 represents the number of Intel 82527 chips on the board.
154 * %NR_SJA1000 represents the number of Philips sja1000 chips on the board.
155 * The flags entry can currently only be %CANDEV_PROGRAMMABLE_IRQ to indicate that
156 * the hardware uses programmable interrupts.
157 * Return Value: The function always returns zero
158 * File: src/ul_usb1.c
160 int ul_usb1_init_hw_data(struct candevice_t *candev)
162 candev->res_addr=RESET_ADDR;
163 candev->nr_82527_chips=NR_82527;
164 candev->nr_sja1000_chips=NR_SJA1000;
165 candev->nr_all_chips=NR_82527+NR_SJA1000;
166 candev->flags |= CANDEV_PROGRAMMABLE_IRQ*0;
171 /** ul_usb1_init_chip_data
172 * ul_usb1_init_chip_data - Initialize chips
173 * @candev: Pointer to candevice/board structure
174 * @chipnr: Number of the CAN chip on the hardware card
176 * The function ul_usb1_init_chip_data() is used to initialize the hardware
177 * structure containing information about the CAN chips.
178 * %CHIP_TYPE represents the type of CAN chip. %CHIP_TYPE can be "i82527" or
180 * The @chip_base_addr entry represents the start of the 'official' memory map
181 * of the installed chip. It's likely that this is the same as the @io_addr
182 * argument supplied at module loading time.
183 * The @clock entry holds the chip clock value in Hz.
184 * The entry @sja_cdr_reg holds hardware specific options for the Clock Divider
185 * register. Options defined in the %sja1000.h file:
186 * %sjaCDR_CLKOUT_MASK, %sjaCDR_CLK_OFF, %sjaCDR_RXINPEN, %sjaCDR_CBP, %sjaCDR_PELICAN
187 * The entry @sja_ocr_reg holds hardware specific options for the Output Control
188 * register. Options defined in the %sja1000.h file:
189 * %sjaOCR_MODE_BIPHASE, %sjaOCR_MODE_TEST, %sjaOCR_MODE_NORMAL, %sjaOCR_MODE_CLOCK,
190 * %sjaOCR_TX0_LH, %sjaOCR_TX1_ZZ.
191 * The entry @int_clk_reg holds hardware specific options for the Clock Out
192 * register. Options defined in the %i82527.h file:
193 * %iCLK_CD0, %iCLK_CD1, %iCLK_CD2, %iCLK_CD3, %iCLK_SL0, %iCLK_SL1.
194 * The entry @int_bus_reg holds hardware specific options for the Bus
195 * Configuration register. Options defined in the %i82527.h file:
196 * %iBUS_DR0, %iBUS_DR1, %iBUS_DT1, %iBUS_POL, %iBUS_CBY.
197 * The entry @int_cpu_reg holds hardware specific options for the cpu interface
198 * register. Options defined in the %i82527.h file:
199 * %iCPU_CEN, %iCPU_MUX, %iCPU_SLP, %iCPU_PWD, %iCPU_DMC, %iCPU_DSC, %iCPU_RST.
200 * Return Value: The function always returns zero
201 * File: src/ul_usb1.c
203 int ul_usb1_init_chip_data(struct candevice_t *candev, int chipnr)
205 /*i82527_fill_chipspecops(candev->chip[chipnr]);*/
206 /*sja1000_fill_chipspecops(candev->chip[chipnr]);*/
207 sja1000p_fill_chipspecops(candev->chip[chipnr]);
209 candev->chip[chipnr]->flags|= CHIP_IRQ_CUSTOM;
211 candev->chip[chipnr]->chip_base_addr=0;
212 candev->chip[chipnr]->clock = 24000000;
213 candev->chip[chipnr]->int_cpu_reg = iCPU_DSC;
214 candev->chip[chipnr]->int_clk_reg = iCLK_SL1;
215 candev->chip[chipnr]->int_bus_reg = iBUS_CBY;
216 candev->chip[chipnr]->sja_cdr_reg = sjaCDR_CBP | sjaCDR_CLK_OFF;
217 candev->chip[chipnr]->sja_ocr_reg = sjaOCR_MODE_NORMAL |
220 candev->chip[chipnr]->chip_data=(void *)malloc(sizeof(struct ul_usb1_chip_data));
221 if (candev->chip[chipnr]->chip_data==NULL)
226 /** ul_usb1_init_obj_data
227 * ul_usb1_init_obj_data - Initialize message buffers
228 * @chip: Pointer to chip specific structure
229 * @objnr: Number of the message buffer
231 * The function ul_usb1_init_obj_data() is used to initialize the hardware
232 * structure containing information about the different message objects on the
233 * CAN chip. In case of the sja1000 there's only one message object but on the
234 * i82527 chip there are 15.
235 * The code below is for a i82527 chip and initializes the object base addresses
236 * The entry @obj_base_addr represents the first memory address of the message
237 * object. In case of the sja1000 @obj_base_addr is taken the same as the chips
239 * Unless the hardware uses a segmented memory map, flags can be set zero.
240 * Return Value: The function always returns zero
241 * File: src/ul_usb1.c
243 int ul_usb1_init_obj_data(struct canchip_t *chip, int objnr)
245 chip->msgobj[objnr]->obj_base_addr=chip->chip_base_addr+(objnr+1)*0x10;
250 /** ul_usb1_program_irq
251 * ul_usb1_program_irq - program interrupts
252 * @candev: Pointer to candevice/board structure
254 * The function ul_usb1_program_irq() is used for hardware that uses
255 * programmable interrupts. If your hardware doesn't use programmable interrupts
256 * you should not set the @candevices_t->flags entry to %CANDEV_PROGRAMMABLE_IRQ and
257 * leave this function unedited. Again this function is hardware specific so
258 * there's no example code.
259 * Return value: The function returns zero on success or %-ENODEV on failure
260 * File: src/ul_usb1.c
262 int ul_usb1_program_irq(struct candevice_t *candev)
267 /** ul_usb1_write_register
268 * ul_usb1_write_register - Low level write register routine
269 * @data: data to be written
270 * @address: memory address to write to
272 * The function ul_usb1_write_register() is used to write to hardware registers
273 * on the CAN chip. You should only have to edit this function if your hardware
274 * uses some specific write process.
275 * Return Value: The function does not return a value
276 * File: src/ul_usb1.c
278 void ul_usb1_write_register(unsigned data, unsigned long address)
280 can_write((uint8_t)(address & 0xFF), (uint8_t *)&data);
283 /** ul_usb1_read_register
284 * ul_usb1_read_register - Low level read register routine
285 * @address: memory address to read from
287 * The function ul_usb1_read_register() is used to read from hardware registers
288 * on the CAN chip. You should only have to edit this function if your hardware
289 * uses some specific read process.
290 * Return Value: The function returns the value stored in @address
291 * File: src/ul_usb1.c
293 unsigned ul_usb1_read_register(unsigned long address)
296 can_read((uint8_t)(address & 0xFF), (uint8_t *)&data);
300 /* !!! Don't change this function !!! */
301 int ul_usb1_register(struct hwspecops_t *hwspecops)
303 hwspecops->request_io = ul_usb1_request_io;
304 hwspecops->release_io = ul_usb1_release_io;
305 hwspecops->reset = ul_usb1_reset;
306 hwspecops->init_hw_data = ul_usb1_init_hw_data;
307 hwspecops->init_chip_data = ul_usb1_init_chip_data;
308 hwspecops->init_obj_data = ul_usb1_init_obj_data;
309 hwspecops->write_register = ul_usb1_write_register;
310 hwspecops->read_register = ul_usb1_read_register;
311 hwspecops->program_irq = ul_usb1_program_irq;
318 /* --------------------------------------------------------------------------------------------------- */
321 // static void ul_usb1_irq(struct urb *urb)
323 // struct usb_ul_usb1 *dev = urb->context;
324 // struct ul_usb1_combo devc;
327 // CANMSG("Interrupt poll\n");
329 // switch (urb->status) {
336 // /* this urb is terminated, clean up */
337 // CANMSG("%s - urb shutting down with status: %d\n", __FUNCTION__, urb->status);
340 // CANMSG("%s - nonzero urb status received: %d\n", __FUNCTION__, urb->status);
347 // dev->candev->chip[0]->chipspecops->irq_handler(0,dev->candev->chip[0]);
348 // CANMSG("Interrupt caught\n");
351 // retval = usb_submit_urb (urb, GFP_ATOMIC);
353 // CANMSG("%s - usb_submit_urb failed with result %d\n",
354 // __FUNCTION__, retval);
357 // static void ul_usb1_delete(struct usb_ul_usb1 *dev)
359 // usb_put_dev(dev->udev);
360 // usb_kill_urb(dev->irq);
361 // usb_free_urb(dev->irq);
362 // kfree(dev->bulk_in_buffer);
363 // kfree(dev->int_in_buffer);
365 // dev->candev->sysdevptr.anydev=NULL;
366 // cleanup_usbdev(dev->candev);
371 // static int ul_usb1_probe(struct usb_interface *interface, const struct usb_device_id *id)
373 // struct usb_ul_usb1 *dev;
374 // struct usb_host_interface *iface_desc;
375 // struct usb_endpoint_descriptor *endpoint;
376 // struct candevice_t *candev;
377 // size_t buffer_size;
379 // int retval = -ENOMEM;
381 // /* allocate memory for our device state and initialize it */
382 // dev = kzalloc(sizeof(*dev), GFP_KERNEL);
384 // err("Out of memory");
387 // sema_init(&dev->limit_sem, WRITES_IN_FLIGHT);
388 // mutex_init(&dev->io_mutex);
389 // spin_lock_init(&dev->err_lock);
390 // init_usb_anchor(&dev->submitted);
392 // // dev->udev = usb_get_dev(interface_to_usbdev(interface));
393 // dev->udev = interface_to_usbdev(interface);
394 // dev->interface = interface;
396 // /* set up the endpoint information */
397 // /* use only the first bulk-in and bulk-out endpoints */
398 // iface_desc = interface->cur_altsetting;
399 // for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
400 // endpoint = &iface_desc->endpoint[i].desc;
402 // if (!dev->bulk_in_endpointAddr &&
403 // usb_endpoint_is_bulk_in(endpoint)) {
404 // /* we found a bulk in endpoint */
405 // buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
406 // dev->bulk_in_size = buffer_size;
407 // dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
408 // dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
409 // if (!dev->bulk_in_buffer) {
410 // err("Could not allocate bulk_in_buffer");
415 // if (!dev->bulk_out_endpointAddr &&
416 // usb_endpoint_is_bulk_out(endpoint)) {
417 // /* we found a bulk out endpoint */
418 // dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
421 // if (!dev->int_in_endpointAddr &&
422 // usb_endpoint_is_int_in(endpoint)) {
423 // /* we found an interrupt in endpoint */
424 // buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
425 // dev->int_in_size = buffer_size;
426 // dev->int_in_endpointAddr = endpoint->bEndpointAddress;
427 // dev->int_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
428 // dev->int_in_interval = endpoint->bInterval;
429 // if (!dev->int_in_buffer) {
430 // err("Could not allocate int_in_buffer");
435 // if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr && dev->int_in_endpointAddr)) {
436 // err("Could not find all bulk-in, bulk-out and interrupt endpoints");
440 // /* save our data pointer in this interface device */
441 // usb_set_intfdata(interface, dev);
443 // if (main_init_done==1)
444 // register_usbdev("ul_usb1",(void *) dev);
446 // mutex_lock(&usbdev_reg_mutex);
447 // if (main_init_done==1)
448 // register_usbdev("ul_usb1",(void *) dev);
450 // for (i=0;i<MAX_HW_CARDS;i++){
451 // if (usbregq[i]==NULL){
452 // usbregq[i]=(struct usbdev_reg_query *)can_checked_malloc(sizeof(struct usbdev_reg_query));
454 // CANMSG("Error allocating usbdev_reg_query");
455 // mutex_unlock(&usbdev_reg_mutex);
458 // sprintf (usbregq[i]->hwname,"ul_usb1");
459 // usbregq[i]->anydev=(void *) dev;
463 // if (i==MAX_HW_CARDS){
464 // CANMSG("No free space to register new card");
465 // mutex_unlock(&usbdev_reg_mutex);
469 // mutex_unlock(&usbdev_reg_mutex);
472 // dev->irq = usb_alloc_urb(0, GFP_KERNEL);
474 // CANMSG("Error allocating usb urb\n");
477 // dev->irq->dev = dev->udev;
478 // usb_fill_int_urb(dev->irq, dev->udev,
479 // usb_rcvintpipe(dev->udev, dev->int_in_endpointAddr),
480 // dev->int_in_buffer, dev->int_in_size,
481 // ul_usb1_irq, dev, dev->int_in_interval);
482 // /* usb_fill_bulk_urb(dev->irq, dev->udev,
483 // usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
484 // dev->int_in_buffer, dev->int_in_size,
485 // ul_usb1_irq, dev);*/
487 // /* dev->irq->transfer_dma = wacom->data_dma;
488 // dev->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;*/
489 // retval=usb_submit_urb(dev->irq, GFP_KERNEL);
491 // CANMSG("INT URB %d\n",retval);
494 // CANMSG("INT URB SUCCCESS\n");
496 // /* let the user know what node this device is now attached to */
497 // info("USB Skeleton device now attached");
501 // ul_usb1_delete(dev);
505 // static void ul_usb1_disconnect(struct usb_interface *interface)
507 // struct usb_ul_usb1 *dev;
508 // int minor = interface->minor;
510 // dev = usb_get_intfdata(interface);
511 // usb_set_intfdata(interface, NULL);
513 // /* prevent more I/O from starting */
514 // mutex_lock(&dev->io_mutex);
515 // dev->interface = NULL;
516 // mutex_unlock(&dev->io_mutex);
518 // //usb_kill_anchored_urbs(&dev->submitted);
520 // ul_usb1_delete(dev);
522 // info("USB Skeleton now disconnected");
525 // static struct usb_driver ul_usb1_driver = {
526 // .name = "ul_usb1-can",
527 // .id_table = ul_usb1_table,
528 // .probe = ul_usb1_probe,
529 // .disconnect = ul_usb1_disconnect,
530 // .id_table = ul_usb1_table,
533 // int ul_usb1_init(void){
534 // return usb_register(&ul_usb1_driver);
537 // void ul_usb1_exit(void){
538 // usb_deregister(&ul_usb1_driver);