lincan/src/proc.c

   1 /* proc.c
   2  * Linux CAN-bus device driver.
   3  * Written by Arnaud Westenberg email:arnaud@wanadoo.nl
   4  * Rewritten for new CAN queues by Pavel Pisa - OCERA team member
   5  * email:pisa@cmp.felk.cvut.cz
   6  * This software is released under the GPL-License.
   7  * Version lincan-0.3  17 Jun 2004
   8  */
   9
  10 #include "../include/can.h"
  11 #include "../include/can_sysdep.h"
  12 #include "../include/main.h"
  13 #include "../include/proc.h"
  14 #include "../include/setup.h"
  15
  16 #define __NO_VERSION__
  17 #include <linux/module.h>
  18 #include <linux/mutex.h>
  19
  20 int add_channel_to_procdir(struct candevice_t *candev);
  21 int remove_channels_from_procdir(void);
  22 int remove_channel_from_procdir(struct candevice_t *candev);
  23 int add_object_to_procdir(int chip_nr);
  24 int remove_object_from_procdir(int chip_nr);
  25
  26 #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,3,0))
  27 static int can_proc_readlink(struct proc_dir_entry *ent, char *page);
  28 #endif
  29
  30 #if  LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,25)
  31 #define CAN_PROC_ROOT (&proc_root)
  32 #else /* >= 2.6.26 */
  33 #define CAN_PROC_ROOT (NULL)
  34 #endif /* >= 2.6.26 */
  35
  36 static int cc=0; /* static counter for each CAN chip */
  37
  38 static struct canproc_t can_proc_base;
  39 static struct canproc_t *base=&can_proc_base;
  40 DEFINE_MUTEX(proc_mutex);               /* synchronize access to canproc_t array */
  41
  42 /* The following functions are needed only for kernel version 2.2. Kernel
  43  * version 2.4 already defines them for us.
  44  */
  45 #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,3,0))
  46 static void can_fill_inode(struct inode *inode, int fill)
  47 {
  48         if (fill)
  49                 MOD_INC_USE_COUNT;
  50         else
  51                 MOD_DEC_USE_COUNT;
  52 }
  53
  54 static struct proc_dir_entry * can_create_proc_entry(const char *name, mode_t mode,
  55                                         struct proc_dir_entry *parent)
  56 {
  57         struct proc_dir_entry *new_entry = NULL;
  58         char *namestore;
  59         int namelen;
  60
  61         if(!name || !parent)
  62                 return NULL;
  63         namelen=strlen(name);
  64         if(!namelen)
  65                 return NULL;
  66
  67         new_entry = (struct proc_dir_entry *)
  68                         can_checked_malloc(sizeof(struct proc_dir_entry)+namelen+1);
  69
  70         if (new_entry == NULL)
  71                 return NULL;
  72
  73         memset(new_entry, 0, sizeof(struct proc_dir_entry));
  74
  75         /* Store copy of the proc entry name */
  76         namestore = ((char *) new_entry) + sizeof(struct proc_dir_entry);
  77         memcpy(namestore, name, namelen + 1);
  78
  79         new_entry->low_ino = 0;
  80         new_entry->namelen = namelen;
  81         new_entry->name = namestore;
  82         new_entry->mode = mode;
  83         new_entry->nlink = 0;
  84         new_entry->fill_inode = can_fill_inode;
  85         new_entry->parent = parent;
  86
  87         proc_register(parent, new_entry);
  88
  89         return new_entry;
  90 }
  91
  92 static int can_remove_proc_entry(struct proc_dir_entry *del, struct proc_dir_entry *parent)
  93 {
  94         if (del != NULL) {
  95                 proc_unregister(parent, del->low_ino);
  96                 can_checked_free(del);
  97                 return 0;
  98         }
  99         else return -ENODEV;
 100 }
 101
 102
 103 static int can_proc_readlink(struct proc_dir_entry *ent, char *page)
 104 {
 105         char *link_dest = (char*)ent->data;
 106
 107         strcpy(page, link_dest);
 108         return strlen(link_dest);
 109 }
 110
 111
 112
 113 /* This compatibility version of proc_symlink does not store local copy of destination */
 114 static inline struct proc_dir_entry *can_proc_symlink(const char *name,
 115                 struct proc_dir_entry *parent, const char *dest)
 116 {
 117         struct proc_dir_entry *entry;
 118
 119
 120         entry = can_create_proc_entry(name, S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO, parent);
 121         if (entry == NULL)
 122                 return NULL;
 123         entry->readlink_proc = can_proc_readlink;
 124         entry->data = dest;
 125         return entry;
 126 }
 127
 128 #else /* Functions forwarded for kernel 2.4 and above */
 129
 130 static inline struct proc_dir_entry * can_create_proc_entry(const char *name, mode_t mode,
 131                                         struct proc_dir_entry *parent)
 132 {
 133         return create_proc_entry(name, mode, parent);
 134 }
 135
 136
 137 /* This does not fully follow linux 2.4 and 2.6 prototype to simplify 2.2.x compatibility */
 138 /* The newer kernels use entry name instead of pointer to the entry */
 139 static int can_remove_proc_entry(struct proc_dir_entry *del, struct proc_dir_entry *parent)
 140 {
 141         if(!del) return -ENODEV;
 142         remove_proc_entry(del->name,parent);
 143         return 0;
 144 }
 145
 146 static inline struct proc_dir_entry *can_proc_symlink(const char *name,
 147                 struct proc_dir_entry *parent, const char *dest)
 148 {
 149         return proc_symlink(name, parent, dest);
 150 }
 151
 152 #endif /* Functions required for kernel 2.2 */
 153
 154 /* can_init_procdir registers the entire CAN directory tree recursively at
 155  * the proc system.
 156  */
 157 int can_init_procdir(void)
 158 {
 159         int board;
 160         struct candevice_t *candev;
 161
 162         mutex_init(&proc_mutex);
 163
 164         base->can_proc_entry = can_create_proc_entry("can", S_IFDIR | S_IRUGO |
 165                                         S_IXUGO, CAN_PROC_ROOT);
 166         if (base->can_proc_entry == NULL)
 167                 return -ENODEV;
 168
 169         for (board=0; board<hardware_p->nr_boards; board++) {
 170                 candev=hardware_p->candevice[board];
 171                 if(candev) add_channel_to_procdir(candev);
 172         }
 173
 174         return 0;
 175 }
 176
 177 /* can_init_procentry registers entry of a new board in CAN directory tree at
 178  * the proc system.
 179  */
 180 int can_init_procentry(int board)
 181 {
 182         struct candevice_t *candev;
 183         candev=hardware_p->candevice[board];
 184         if(candev)
 185                 return add_channel_to_procdir(candev);
 186         return -ENODEV;
 187 }
 188
 189 /* can_delete_procdir removes the entire CAN tree from the proc system */
 190 int can_delete_procdir(void)
 191 {
 192         if (remove_channels_from_procdir())
 193                 return -ENODEV;
 194         /* name: "can" */
 195         if (can_remove_proc_entry(base->can_proc_entry, CAN_PROC_ROOT))
 196                 return -ENODEV;
 197
 198         return 0;
 199 }
 200
 201 /* can_delete_procentry removes device entries from CAN tree in the proc system */
 202 int can_delete_procentry(struct candevice_t *candev)
 203 {
 204         if (remove_channel_from_procdir(candev))
 205                 return -ENODEV;
 206
 207         return 0;
 208 }
 209
 210 static int can_chip_procinfo(char *buf, char **start, off_t offset,
 211                  int count, int *eof, void *data)
 212 {
 213         struct canchip_t *chip=data;
 214         int len=0;
 215
 216         /* Generic chip info */
 217         len += sprintf(buf+len,"type    : %s\n",chip->chip_type);
 218         len += sprintf(buf+len,"index   : %d\n",chip->chip_idx);
 219         len += sprintf(buf+len,"irq     : %d\n",chip->chip_irq);
 220         len += sprintf(buf+len,"addr    : %lu\n",
 221                         can_ioptr2ulong(chip->chip_base_addr));
 222         len += sprintf(buf+len,"config  : %s\n",
 223                         (chip->flags & CHIP_CONFIGURED) ? "yes":"no");
 224         len += sprintf(buf+len,"clock   : %ld Hz\n",chip->clock);
 225         len += sprintf(buf+len,"baud    : %ld\n",chip->baudrate);
 226         len += sprintf(buf+len,"num obj : %d\n",chip->max_objects);
 227
 228
 229 #if 0
 230         /* Chip specific info if available */
 231         if(chip->chipspecops->get_info)
 232                 len += (chip->chipspecops->get_info)(chip,buf+len);
 233 #endif
 234
 235         *eof = 1;
 236         return len;
 237 }
 238
 239
 240 int add_channel_to_procdir(struct candevice_t *candev)
 241 {
 242         int i=0;
 243
 244         mutex_lock(&proc_mutex);
 245         for (i=0; i < MAX_TOT_CHIPS; i++){
 246                 if (!chips_p[i]) continue;
 247                 if (chips_p[i]->hostdevice != candev) continue;
 248
 249                 base->channel[i] = (struct channelproc_t *)
 250                         can_checked_malloc(sizeof(struct channelproc_t));
 251                 if (base->channel[i] == NULL){
 252                         mutex_unlock(&proc_mutex);
 253                         return -ENOMEM;
 254                 }
 255
 256                 sprintf(base->channel[i]->ch_name, "channel%d",i);
 257
 258                 base->channel[i]->ch_entry = can_create_proc_entry(
 259                                                 base->channel[i]->ch_name,
 260                                                 S_IFDIR | S_IRUGO |S_IXUGO,
 261                                                 base->can_proc_entry);
 262
 263                 if (base->channel[i]->ch_entry == NULL){
 264                         mutex_unlock(&proc_mutex);
 265                         return -ENODEV;
 266                 }
 267
 268                 add_object_to_procdir(i);
 269
 270                 create_proc_read_entry("chip_info",        /* proc entry name */
 271                                        0,                  /* protection mask, 0->default */
 272                                        base->channel[i]->ch_entry,  /* parent dir, NULL->/proc */
 273                                        can_chip_procinfo,
 274                                        chips_p[i]);
 275                 cc++;
 276         }
 277         mutex_unlock(&proc_mutex);
 278
 279         return 0;
 280 }
 281
 282 int remove_channels_from_procdir(void)
 283 {
 284         int i=0;
 285
 286         mutex_lock(&proc_mutex);
 287         for (i=0; i < MAX_TOT_CHIPS; i++){
 288                 if (!chips_p[i]) continue;
 289
 290                 cc--;
 291
 292                 if(!base->channel[i]) continue;
 293
 294                 remove_proc_entry("chip_info", base->channel[i]->ch_entry);
 295
 296                 if (remove_object_from_procdir(i)){
 297                         mutex_unlock(&proc_mutex);
 298                         return -ENODEV;
 299                 }
 300
 301                 /* name: base->channel[cc]->ch_name */
 302                 if (can_remove_proc_entry(base->channel[i]->ch_entry,
 303                                                         base->can_proc_entry)){
 304                         mutex_unlock(&proc_mutex);
 305                         return -ENODEV;
 306                 }
 307
 308                 can_checked_free(base->channel[i]);
 309                 base->channel[i] = NULL;
 310         }
 311         mutex_unlock(&proc_mutex);
 312
 313         return 0;
 314 }
 315
 316 int remove_channel_from_procdir(struct candevice_t *candev)
 317 {
 318         int i=0,j=0;
 319
 320         mutex_lock(&proc_mutex);
 321         for (i=0; i < MAX_TOT_CHIPS; i++){
 322                 if (!chips_p[i]) continue;
 323                 if (chips_p[i]->hostdevice != candev) continue;
 324                 if (!base->channel[i]) continue;
 325
 326                 remove_proc_entry("chip_info", base->channel[i]->ch_entry);
 327
 328                 if (remove_object_from_procdir(i)){
 329                         mutex_unlock(&proc_mutex);
 330                         return -ENODEV;
 331                 }
 332
 333                 /* name: base->channel[cc]->ch_name */
 334                 if (can_remove_proc_entry(base->channel[i]->ch_entry,
 335                                                         base->can_proc_entry)){
 336                         mutex_unlock(&proc_mutex);
 337                         return -ENODEV;
 338                 }
 339
 340                 can_checked_free(base->channel[i]);
 341                 base->channel[i] = NULL;
 342
 343                 cc--;
 344         }
 345         mutex_unlock(&proc_mutex);
 346
 347         return 0;
 348 }
 349
 350
 351 int add_object_to_procdir(int chip_nr)
 352 {
 353         int i, max_objects;
 354
 355         max_objects=chips_p[chip_nr]->max_objects;
 356
 357         for (i=0; i<max_objects; i++) {
 358                 base->channel[chip_nr]->object[i] = (struct objectproc_t *)
 359                         can_checked_malloc(sizeof(struct objectproc_t));
 360
 361                 if (base->channel[chip_nr]->object[i] == NULL)
 362                         return -ENOMEM;
 363
 364                 sprintf(base->channel[chip_nr]->object[i]->obj_name,"object%d",i);
 365                 sprintf(base->channel[chip_nr]->object[i]->lnk_name,"dev");
 366
 367                 base->channel[chip_nr]->object[i]->obj_entry = can_create_proc_entry(
 368                                 base->channel[chip_nr]->object[i]->obj_name,
 369                                 S_IFDIR | S_IRUGO | S_IXUGO,
 370                                 base->channel[chip_nr]->ch_entry);
 371                 if (base->channel[chip_nr]->object[i]->obj_entry == NULL)
 372                         return -ENODEV;
 373
 374                 sprintf(base->channel[chip_nr]->object[i]->lnk_dev,"/dev/can%d",
 375                         chips_p[chip_nr]->msgobj[i]->minor);
 376
 377                 base->channel[chip_nr]->object[i]->lnk = can_proc_symlink(
 378                                 base->channel[chip_nr]->object[i]->lnk_name,
 379                                 base->channel[chip_nr]->object[i]->obj_entry,
 380                                 base->channel[chip_nr]->object[i]->lnk_dev);
 381                 if (base->channel[chip_nr]->object[i]->lnk == NULL)
 382                         return -ENODEV;
 383
 384         }
 385         return 0;
 386 }
 387
 388 int remove_object_from_procdir(int chip_nr)
 389 {
 390         int i=0, obj=0;
 391
 392         obj=chips_p[chip_nr]->max_objects;
 393
 394         for (i=0; i<obj; i++) {
 395                 if(!base->channel[chip_nr]->object[i]) continue;
 396
 397                 /* name: base->channel[chip_nr]->object[i]->lnk_name */
 398                 if (can_remove_proc_entry( base->channel[chip_nr]->object[i]->lnk,
 399                                 base->channel[chip_nr]->object[i]->obj_entry))
 400                         return -ENODEV;
 401                 /* name: base->channel[chip_nr]->object[i]->obj_name */
 402                 if (can_remove_proc_entry(
 403                                 base->channel[chip_nr]->object[i]->obj_entry,
 404                                 base->channel[chip_nr]->ch_entry))
 405                         return -ENODEV;
 406
 407                 can_checked_free(base->channel[chip_nr]->object[i]);
 408
 409                 base->channel[chip_nr]->object[i]=NULL;
 410         }
 411         return 0;
 412 }
 413