drivers/media/usb/pvrusb2/pvrusb2-sysfs.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *
   4  *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
   5  */
   6
   7 #include <linux/string.h>
   8 #include <linux/slab.h>
   9 #include "pvrusb2-sysfs.h"
  10 #include "pvrusb2-hdw.h"
  11 #include "pvrusb2-debug.h"
  12 #ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
  13 #include "pvrusb2-debugifc.h"
  14 #endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
  15
  16 #define pvr2_sysfs_trace(...) pvr2_trace(PVR2_TRACE_SYSFS,__VA_ARGS__)
  17
  18 struct pvr2_sysfs {
  19         struct pvr2_channel channel;
  20         struct device *class_dev;
  21 #ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
  22         struct pvr2_sysfs_debugifc *debugifc;
  23 #endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
  24         struct pvr2_sysfs_ctl_item *item_first;
  25         struct pvr2_sysfs_ctl_item *item_last;
  26         struct device_attribute attr_v4l_minor_number;
  27         struct device_attribute attr_v4l_radio_minor_number;
  28         struct device_attribute attr_unit_number;
  29         struct device_attribute attr_bus_info;
  30         struct device_attribute attr_hdw_name;
  31         struct device_attribute attr_hdw_desc;
  32         int v4l_minor_number_created_ok;
  33         int v4l_radio_minor_number_created_ok;
  34         int unit_number_created_ok;
  35         int bus_info_created_ok;
  36         int hdw_name_created_ok;
  37         int hdw_desc_created_ok;
  38 };
  39
  40 #ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
  41 struct pvr2_sysfs_debugifc {
  42         struct device_attribute attr_debugcmd;
  43         struct device_attribute attr_debuginfo;
  44         int debugcmd_created_ok;
  45         int debuginfo_created_ok;
  46 };
  47 #endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
  48
  49 struct pvr2_sysfs_ctl_item {
  50         struct device_attribute attr_name;
  51         struct device_attribute attr_type;
  52         struct device_attribute attr_min;
  53         struct device_attribute attr_max;
  54         struct device_attribute attr_def;
  55         struct device_attribute attr_enum;
  56         struct device_attribute attr_bits;
  57         struct device_attribute attr_val;
  58         struct device_attribute attr_custom;
  59         struct pvr2_ctrl *cptr;
  60         int ctl_id;
  61         struct pvr2_sysfs *chptr;
  62         struct pvr2_sysfs_ctl_item *item_next;
  63         struct attribute *attr_gen[8];
  64         struct attribute_group grp;
  65         int created_ok;
  66         char name[80];
  67 };
  68
  69 static ssize_t show_name(struct device *class_dev,
  70                          struct device_attribute *attr,
  71                          char *buf)
  72 {
  73         struct pvr2_sysfs_ctl_item *cip;
  74         const char *name;
  75         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_name);
  76         name = pvr2_ctrl_get_desc(cip->cptr);
  77         pvr2_sysfs_trace("pvr2_sysfs(%p) show_name(cid=%d) is %s",
  78                          cip->chptr, cip->ctl_id, name);
  79         if (!name) return -EINVAL;
  80         return sysfs_emit(buf, "%s\n", name);
  81 }
  82
  83 static ssize_t show_type(struct device *class_dev,
  84                          struct device_attribute *attr,
  85                          char *buf)
  86 {
  87         struct pvr2_sysfs_ctl_item *cip;
  88         const char *name;
  89         enum pvr2_ctl_type tp;
  90         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_type);
  91         tp = pvr2_ctrl_get_type(cip->cptr);
  92         switch (tp) {
  93         case pvr2_ctl_int: name = "integer"; break;
  94         case pvr2_ctl_enum: name = "enum"; break;
  95         case pvr2_ctl_bitmask: name = "bitmask"; break;
  96         case pvr2_ctl_bool: name = "boolean"; break;
  97         default: name = "?"; break;
  98         }
  99         pvr2_sysfs_trace("pvr2_sysfs(%p) show_type(cid=%d) is %s",
 100                          cip->chptr, cip->ctl_id, name);
 101         return sysfs_emit(buf, "%s\n", name);
 102 }
 103
 104 static ssize_t show_min(struct device *class_dev,
 105                         struct device_attribute *attr,
 106                         char *buf)
 107 {
 108         struct pvr2_sysfs_ctl_item *cip;
 109         long val;
 110         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_min);
 111         val = pvr2_ctrl_get_min(cip->cptr);
 112         pvr2_sysfs_trace("pvr2_sysfs(%p) show_min(cid=%d) is %ld",
 113                          cip->chptr, cip->ctl_id, val);
 114         return sysfs_emit(buf, "%ld\n", val);
 115 }
 116
 117 static ssize_t show_max(struct device *class_dev,
 118                         struct device_attribute *attr,
 119                         char *buf)
 120 {
 121         struct pvr2_sysfs_ctl_item *cip;
 122         long val;
 123         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_max);
 124         val = pvr2_ctrl_get_max(cip->cptr);
 125         pvr2_sysfs_trace("pvr2_sysfs(%p) show_max(cid=%d) is %ld",
 126                          cip->chptr, cip->ctl_id, val);
 127         return sysfs_emit(buf, "%ld\n", val);
 128 }
 129
 130 static ssize_t show_def(struct device *class_dev,
 131                         struct device_attribute *attr,
 132                         char *buf)
 133 {
 134         struct pvr2_sysfs_ctl_item *cip;
 135         int val;
 136         int ret;
 137         unsigned int cnt = 0;
 138         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_def);
 139         ret = pvr2_ctrl_get_def(cip->cptr, &val);
 140         if (ret < 0) return ret;
 141         ret = pvr2_ctrl_value_to_sym(cip->cptr, ~0, val,
 142                                      buf, PAGE_SIZE - 1, &cnt);
 143         pvr2_sysfs_trace("pvr2_sysfs(%p) show_def(cid=%d) is %.*s (%d)",
 144                          cip->chptr, cip->ctl_id, cnt, buf, val);
 145         buf[cnt] = '\n';
 146         return cnt + 1;
 147 }
 148
 149 static ssize_t show_val_norm(struct device *class_dev,
 150                              struct device_attribute *attr,
 151                              char *buf)
 152 {
 153         struct pvr2_sysfs_ctl_item *cip;
 154         int val;
 155         int ret;
 156         unsigned int cnt = 0;
 157         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_val);
 158         ret = pvr2_ctrl_get_value(cip->cptr, &val);
 159         if (ret < 0) return ret;
 160         ret = pvr2_ctrl_value_to_sym(cip->cptr, ~0, val,
 161                                      buf, PAGE_SIZE - 1, &cnt);
 162         pvr2_sysfs_trace("pvr2_sysfs(%p) show_val_norm(cid=%d) is %.*s (%d)",
 163                          cip->chptr, cip->ctl_id, cnt, buf, val);
 164         buf[cnt] = '\n';
 165         return cnt+1;
 166 }
 167
 168 static ssize_t show_val_custom(struct device *class_dev,
 169                                struct device_attribute *attr,
 170                                char *buf)
 171 {
 172         struct pvr2_sysfs_ctl_item *cip;
 173         int val;
 174         int ret;
 175         unsigned int cnt = 0;
 176         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_custom);
 177         ret = pvr2_ctrl_get_value(cip->cptr, &val);
 178         if (ret < 0) return ret;
 179         ret = pvr2_ctrl_custom_value_to_sym(cip->cptr, ~0, val,
 180                                             buf, PAGE_SIZE - 1, &cnt);
 181         pvr2_sysfs_trace("pvr2_sysfs(%p) show_val_custom(cid=%d) is %.*s (%d)",
 182                          cip->chptr, cip->ctl_id, cnt, buf, val);
 183         buf[cnt] = '\n';
 184         return cnt+1;
 185 }
 186
 187 static ssize_t show_enum(struct device *class_dev,
 188                          struct device_attribute *attr,
 189                          char *buf)
 190 {
 191         struct pvr2_sysfs_ctl_item *cip;
 192         long val;
 193         unsigned int bcnt, ccnt, ecnt;
 194         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_enum);
 195         ecnt = pvr2_ctrl_get_cnt(cip->cptr);
 196         bcnt = 0;
 197         for (val = 0; val < ecnt; val++) {
 198                 pvr2_ctrl_get_valname(cip->cptr, val, buf + bcnt,
 199                                       PAGE_SIZE - bcnt, &ccnt);
 200                 if (!ccnt) continue;
 201                 bcnt += ccnt;
 202                 if (bcnt >= PAGE_SIZE) break;
 203                 buf[bcnt] = '\n';
 204                 bcnt++;
 205         }
 206         pvr2_sysfs_trace("pvr2_sysfs(%p) show_enum(cid=%d)",
 207                          cip->chptr, cip->ctl_id);
 208         return bcnt;
 209 }
 210
 211 static ssize_t show_bits(struct device *class_dev,
 212                          struct device_attribute *attr,
 213                          char *buf)
 214 {
 215         struct pvr2_sysfs_ctl_item *cip;
 216         int valid_bits, msk;
 217         unsigned int bcnt, ccnt;
 218         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_bits);
 219         valid_bits = pvr2_ctrl_get_mask(cip->cptr);
 220         bcnt = 0;
 221         for (msk = 1; valid_bits; msk <<= 1) {
 222                 if (!(msk & valid_bits)) continue;
 223                 valid_bits &= ~msk;
 224                 pvr2_ctrl_get_valname(cip->cptr, msk, buf + bcnt,
 225                                       PAGE_SIZE - bcnt, &ccnt);
 226                 bcnt += ccnt;
 227                 if (bcnt >= PAGE_SIZE) break;
 228                 buf[bcnt] = '\n';
 229                 bcnt++;
 230         }
 231         pvr2_sysfs_trace("pvr2_sysfs(%p) show_bits(cid=%d)",
 232                          cip->chptr, cip->ctl_id);
 233         return bcnt;
 234 }
 235
 236 static int store_val_any(struct pvr2_sysfs_ctl_item *cip, int customfl,
 237                          const char *buf,unsigned int count)
 238 {
 239         int ret;
 240         int mask,val;
 241         if (customfl) {
 242                 ret = pvr2_ctrl_custom_sym_to_value(cip->cptr, buf, count,
 243                                                     &mask, &val);
 244         } else {
 245                 ret = pvr2_ctrl_sym_to_value(cip->cptr, buf, count,
 246                                              &mask, &val);
 247         }
 248         if (ret < 0) return ret;
 249         ret = pvr2_ctrl_set_mask_value(cip->cptr, mask, val);
 250         pvr2_hdw_commit_ctl(cip->chptr->channel.hdw);
 251         return ret;
 252 }
 253
 254 static ssize_t store_val_norm(struct device *class_dev,
 255                               struct device_attribute *attr,
 256                               const char *buf, size_t count)
 257 {
 258         struct pvr2_sysfs_ctl_item *cip;
 259         int ret;
 260         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_val);
 261         pvr2_sysfs_trace("pvr2_sysfs(%p) store_val_norm(cid=%d) \"%.*s\"",
 262                          cip->chptr, cip->ctl_id, (int)count, buf);
 263         ret = store_val_any(cip, 0, buf, count);
 264         if (!ret) ret = count;
 265         return ret;
 266 }
 267
 268 static ssize_t store_val_custom(struct device *class_dev,
 269                                 struct device_attribute *attr,
 270                                 const char *buf, size_t count)
 271 {
 272         struct pvr2_sysfs_ctl_item *cip;
 273         int ret;
 274         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_custom);
 275         pvr2_sysfs_trace("pvr2_sysfs(%p) store_val_custom(cid=%d) \"%.*s\"",
 276                          cip->chptr, cip->ctl_id, (int)count, buf);
 277         ret = store_val_any(cip, 1, buf, count);
 278         if (!ret) ret = count;
 279         return ret;
 280 }
 281
 282 static void pvr2_sysfs_add_control(struct pvr2_sysfs *sfp,int ctl_id)
 283 {
 284         struct pvr2_sysfs_ctl_item *cip;
 285         struct pvr2_ctrl *cptr;
 286         unsigned int cnt,acnt;
 287         int ret;
 288
 289         cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,ctl_id);
 290         if (!cptr) return;
 291
 292         cip = kzalloc(sizeof(*cip),GFP_KERNEL);
 293         if (!cip) return;
 294         pvr2_sysfs_trace("Creating pvr2_sysfs_ctl_item id=%p",cip);
 295
 296         cip->cptr = cptr;
 297         cip->ctl_id = ctl_id;
 298
 299         cip->chptr = sfp;
 300         cip->item_next = NULL;
 301         if (sfp->item_last) {
 302                 sfp->item_last->item_next = cip;
 303         } else {
 304                 sfp->item_first = cip;
 305         }
 306         sfp->item_last = cip;
 307
 308         sysfs_attr_init(&cip->attr_name.attr);
 309         cip->attr_name.attr.name = "name";
 310         cip->attr_name.attr.mode = S_IRUGO;
 311         cip->attr_name.show = show_name;
 312
 313         sysfs_attr_init(&cip->attr_type.attr);
 314         cip->attr_type.attr.name = "type";
 315         cip->attr_type.attr.mode = S_IRUGO;
 316         cip->attr_type.show = show_type;
 317
 318         sysfs_attr_init(&cip->attr_min.attr);
 319         cip->attr_min.attr.name = "min_val";
 320         cip->attr_min.attr.mode = S_IRUGO;
 321         cip->attr_min.show = show_min;
 322
 323         sysfs_attr_init(&cip->attr_max.attr);
 324         cip->attr_max.attr.name = "max_val";
 325         cip->attr_max.attr.mode = S_IRUGO;
 326         cip->attr_max.show = show_max;
 327
 328         sysfs_attr_init(&cip->attr_def.attr);
 329         cip->attr_def.attr.name = "def_val";
 330         cip->attr_def.attr.mode = S_IRUGO;
 331         cip->attr_def.show = show_def;
 332
 333         sysfs_attr_init(&cip->attr_val.attr);
 334         cip->attr_val.attr.name = "cur_val";
 335         cip->attr_val.attr.mode = S_IRUGO;
 336
 337         sysfs_attr_init(&cip->attr_custom.attr);
 338         cip->attr_custom.attr.name = "custom_val";
 339         cip->attr_custom.attr.mode = S_IRUGO;
 340
 341         sysfs_attr_init(&cip->attr_enum.attr);
 342         cip->attr_enum.attr.name = "enum_val";
 343         cip->attr_enum.attr.mode = S_IRUGO;
 344         cip->attr_enum.show = show_enum;
 345
 346         sysfs_attr_init(&cip->attr_bits.attr);
 347         cip->attr_bits.attr.name = "bit_val";
 348         cip->attr_bits.attr.mode = S_IRUGO;
 349         cip->attr_bits.show = show_bits;
 350
 351         if (pvr2_ctrl_is_writable(cptr)) {
 352                 cip->attr_val.attr.mode |= S_IWUSR|S_IWGRP;
 353                 cip->attr_custom.attr.mode |= S_IWUSR|S_IWGRP;
 354         }
 355
 356         acnt = 0;
 357         cip->attr_gen[acnt++] = &cip->attr_name.attr;
 358         cip->attr_gen[acnt++] = &cip->attr_type.attr;
 359         cip->attr_gen[acnt++] = &cip->attr_val.attr;
 360         cip->attr_gen[acnt++] = &cip->attr_def.attr;
 361         cip->attr_val.show = show_val_norm;
 362         cip->attr_val.store = store_val_norm;
 363         if (pvr2_ctrl_has_custom_symbols(cptr)) {
 364                 cip->attr_gen[acnt++] = &cip->attr_custom.attr;
 365                 cip->attr_custom.show = show_val_custom;
 366                 cip->attr_custom.store = store_val_custom;
 367         }
 368         switch (pvr2_ctrl_get_type(cptr)) {
 369         case pvr2_ctl_enum:
 370                 // Control is an enumeration
 371                 cip->attr_gen[acnt++] = &cip->attr_enum.attr;
 372                 break;
 373         case pvr2_ctl_int:
 374                 // Control is an integer
 375                 cip->attr_gen[acnt++] = &cip->attr_min.attr;
 376                 cip->attr_gen[acnt++] = &cip->attr_max.attr;
 377                 break;
 378         case pvr2_ctl_bitmask:
 379                 // Control is an bitmask
 380                 cip->attr_gen[acnt++] = &cip->attr_bits.attr;
 381                 break;
 382         default: break;
 383         }
 384
 385         cnt = scnprintf(cip->name,sizeof(cip->name)-1,"ctl_%s",
 386                         pvr2_ctrl_get_name(cptr));
 387         cip->name[cnt] = 0;
 388         cip->grp.name = cip->name;
 389         cip->grp.attrs = cip->attr_gen;
 390
 391         ret = sysfs_create_group(&sfp->class_dev->kobj,&cip->grp);
 392         if (ret) {
 393                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 394                            "sysfs_create_group error: %d",
 395                            ret);
 396                 return;
 397         }
 398         cip->created_ok = !0;
 399 }
 400
 401 #ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
 402 static ssize_t debuginfo_show(struct device *, struct device_attribute *,
 403                               char *);
 404 static ssize_t debugcmd_show(struct device *, struct device_attribute *,
 405                              char *);
 406 static ssize_t debugcmd_store(struct device *, struct device_attribute *,
 407                               const char *, size_t count);
 408
 409 static void pvr2_sysfs_add_debugifc(struct pvr2_sysfs *sfp)
 410 {
 411         struct pvr2_sysfs_debugifc *dip;
 412         int ret;
 413
 414         dip = kzalloc(sizeof(*dip),GFP_KERNEL);
 415         if (!dip) return;
 416         sysfs_attr_init(&dip->attr_debugcmd.attr);
 417         dip->attr_debugcmd.attr.name = "debugcmd";
 418         dip->attr_debugcmd.attr.mode = S_IRUGO|S_IWUSR|S_IWGRP;
 419         dip->attr_debugcmd.show = debugcmd_show;
 420         dip->attr_debugcmd.store = debugcmd_store;
 421         sysfs_attr_init(&dip->attr_debuginfo.attr);
 422         dip->attr_debuginfo.attr.name = "debuginfo";
 423         dip->attr_debuginfo.attr.mode = S_IRUGO;
 424         dip->attr_debuginfo.show = debuginfo_show;
 425         sfp->debugifc = dip;
 426         ret = device_create_file(sfp->class_dev,&dip->attr_debugcmd);
 427         if (ret < 0) {
 428                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 429                            "device_create_file error: %d",
 430                            ret);
 431         } else {
 432                 dip->debugcmd_created_ok = !0;
 433         }
 434         ret = device_create_file(sfp->class_dev,&dip->attr_debuginfo);
 435         if (ret < 0) {
 436                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 437                            "device_create_file error: %d",
 438                            ret);
 439         } else {
 440                 dip->debuginfo_created_ok = !0;
 441         }
 442 }
 443
 444
 445 static void pvr2_sysfs_tear_down_debugifc(struct pvr2_sysfs *sfp)
 446 {
 447         if (!sfp->debugifc) return;
 448         if (sfp->debugifc->debuginfo_created_ok) {
 449                 device_remove_file(sfp->class_dev,
 450                                          &sfp->debugifc->attr_debuginfo);
 451         }
 452         if (sfp->debugifc->debugcmd_created_ok) {
 453                 device_remove_file(sfp->class_dev,
 454                                          &sfp->debugifc->attr_debugcmd);
 455         }
 456         kfree(sfp->debugifc);
 457         sfp->debugifc = NULL;
 458 }
 459 #endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
 460
 461
 462 static void pvr2_sysfs_add_controls(struct pvr2_sysfs *sfp)
 463 {
 464         unsigned int idx,cnt;
 465         cnt = pvr2_hdw_get_ctrl_count(sfp->channel.hdw);
 466         for (idx = 0; idx < cnt; idx++) {
 467                 pvr2_sysfs_add_control(sfp,idx);
 468         }
 469 }
 470
 471
 472 static void pvr2_sysfs_tear_down_controls(struct pvr2_sysfs *sfp)
 473 {
 474         struct pvr2_sysfs_ctl_item *cip1,*cip2;
 475         for (cip1 = sfp->item_first; cip1; cip1 = cip2) {
 476                 cip2 = cip1->item_next;
 477                 if (cip1->created_ok) {
 478                         sysfs_remove_group(&sfp->class_dev->kobj,&cip1->grp);
 479                 }
 480                 pvr2_sysfs_trace("Destroying pvr2_sysfs_ctl_item id=%p",cip1);
 481                 kfree(cip1);
 482         }
 483 }
 484
 485
 486 static void pvr2_sysfs_release(struct device *class_dev)
 487 {
 488         pvr2_sysfs_trace("Releasing class_dev id=%p",class_dev);
 489         kfree(class_dev);
 490 }
 491
 492
 493 static struct class pvr2_class = {
 494         .name           = "pvrusb2",
 495         .dev_release    = pvr2_sysfs_release,
 496 };
 497
 498
 499 static void class_dev_destroy(struct pvr2_sysfs *sfp)
 500 {
 501         struct device *dev;
 502         if (!sfp->class_dev) return;
 503 #ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
 504         pvr2_sysfs_tear_down_debugifc(sfp);
 505 #endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
 506         pvr2_sysfs_tear_down_controls(sfp);
 507         if (sfp->hdw_desc_created_ok) {
 508                 device_remove_file(sfp->class_dev,
 509                                    &sfp->attr_hdw_desc);
 510         }
 511         if (sfp->hdw_name_created_ok) {
 512                 device_remove_file(sfp->class_dev,
 513                                    &sfp->attr_hdw_name);
 514         }
 515         if (sfp->bus_info_created_ok) {
 516                 device_remove_file(sfp->class_dev,
 517                                          &sfp->attr_bus_info);
 518         }
 519         if (sfp->v4l_minor_number_created_ok) {
 520                 device_remove_file(sfp->class_dev,
 521                                          &sfp->attr_v4l_minor_number);
 522         }
 523         if (sfp->v4l_radio_minor_number_created_ok) {
 524                 device_remove_file(sfp->class_dev,
 525                                          &sfp->attr_v4l_radio_minor_number);
 526         }
 527         if (sfp->unit_number_created_ok) {
 528                 device_remove_file(sfp->class_dev,
 529                                          &sfp->attr_unit_number);
 530         }
 531         pvr2_sysfs_trace("Destroying class_dev id=%p",sfp->class_dev);
 532         dev_set_drvdata(sfp->class_dev, NULL);
 533         dev = sfp->class_dev->parent;
 534         sfp->class_dev->parent = NULL;
 535         put_device(dev);
 536         device_unregister(sfp->class_dev);
 537         sfp->class_dev = NULL;
 538 }
 539
 540
 541 static ssize_t v4l_minor_number_show(struct device *class_dev,
 542                                      struct device_attribute *attr, char *buf)
 543 {
 544         struct pvr2_sysfs *sfp;
 545         sfp = dev_get_drvdata(class_dev);
 546         if (!sfp) return -EINVAL;
 547         return sysfs_emit(buf, "%d\n",
 548                          pvr2_hdw_v4l_get_minor_number(sfp->channel.hdw,
 549                                                        pvr2_v4l_type_video));
 550 }
 551
 552
 553 static ssize_t bus_info_show(struct device *class_dev,
 554                              struct device_attribute *attr, char *buf)
 555 {
 556         struct pvr2_sysfs *sfp;
 557         sfp = dev_get_drvdata(class_dev);
 558         if (!sfp) return -EINVAL;
 559         return sysfs_emit(buf, "%s\n",
 560                          pvr2_hdw_get_bus_info(sfp->channel.hdw));
 561 }
 562
 563
 564 static ssize_t hdw_name_show(struct device *class_dev,
 565                              struct device_attribute *attr, char *buf)
 566 {
 567         struct pvr2_sysfs *sfp;
 568         sfp = dev_get_drvdata(class_dev);
 569         if (!sfp) return -EINVAL;
 570         return sysfs_emit(buf, "%s\n",
 571                          pvr2_hdw_get_type(sfp->channel.hdw));
 572 }
 573
 574
 575 static ssize_t hdw_desc_show(struct device *class_dev,
 576                              struct device_attribute *attr, char *buf)
 577 {
 578         struct pvr2_sysfs *sfp;
 579         sfp = dev_get_drvdata(class_dev);
 580         if (!sfp) return -EINVAL;
 581         return sysfs_emit(buf, "%s\n",
 582                          pvr2_hdw_get_desc(sfp->channel.hdw));
 583 }
 584
 585
 586 static ssize_t v4l_radio_minor_number_show(struct device *class_dev,
 587                                            struct device_attribute *attr,
 588                                            char *buf)
 589 {
 590         struct pvr2_sysfs *sfp;
 591         sfp = dev_get_drvdata(class_dev);
 592         if (!sfp) return -EINVAL;
 593         return sysfs_emit(buf, "%d\n",
 594                          pvr2_hdw_v4l_get_minor_number(sfp->channel.hdw,
 595                                                        pvr2_v4l_type_radio));
 596 }
 597
 598
 599 static ssize_t unit_number_show(struct device *class_dev,
 600                                 struct device_attribute *attr, char *buf)
 601 {
 602         struct pvr2_sysfs *sfp;
 603         sfp = dev_get_drvdata(class_dev);
 604         if (!sfp) return -EINVAL;
 605         return sysfs_emit(buf, "%d\n",
 606                          pvr2_hdw_get_unit_number(sfp->channel.hdw));
 607 }
 608
 609
 610 static void class_dev_create(struct pvr2_sysfs *sfp)
 611 {
 612         struct usb_device *usb_dev;
 613         struct device *class_dev;
 614         int ret;
 615
 616         usb_dev = pvr2_hdw_get_dev(sfp->channel.hdw);
 617         if (!usb_dev) return;
 618         class_dev = kzalloc(sizeof(*class_dev),GFP_KERNEL);
 619         if (!class_dev) return;
 620
 621         pvr2_sysfs_trace("Creating class_dev id=%p",class_dev);
 622
 623         class_dev->class = &pvr2_class;
 624
 625         dev_set_name(class_dev, "%s",
 626                      pvr2_hdw_get_device_identifier(sfp->channel.hdw));
 627
 628         class_dev->parent = get_device(&usb_dev->dev);
 629
 630         sfp->class_dev = class_dev;
 631         dev_set_drvdata(class_dev, sfp);
 632         ret = device_register(class_dev);
 633         if (ret) {
 634                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 635                            "device_register failed");
 636                 put_device(class_dev);
 637                 return;
 638         }
 639
 640         sysfs_attr_init(&sfp->attr_v4l_minor_number.attr);
 641         sfp->attr_v4l_minor_number.attr.name = "v4l_minor_number";
 642         sfp->attr_v4l_minor_number.attr.mode = S_IRUGO;
 643         sfp->attr_v4l_minor_number.show = v4l_minor_number_show;
 644         sfp->attr_v4l_minor_number.store = NULL;
 645         ret = device_create_file(sfp->class_dev,
 646                                        &sfp->attr_v4l_minor_number);
 647         if (ret < 0) {
 648                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 649                            "device_create_file error: %d",
 650                            ret);
 651         } else {
 652                 sfp->v4l_minor_number_created_ok = !0;
 653         }
 654
 655         sysfs_attr_init(&sfp->attr_v4l_radio_minor_number.attr);
 656         sfp->attr_v4l_radio_minor_number.attr.name = "v4l_radio_minor_number";
 657         sfp->attr_v4l_radio_minor_number.attr.mode = S_IRUGO;
 658         sfp->attr_v4l_radio_minor_number.show = v4l_radio_minor_number_show;
 659         sfp->attr_v4l_radio_minor_number.store = NULL;
 660         ret = device_create_file(sfp->class_dev,
 661                                        &sfp->attr_v4l_radio_minor_number);
 662         if (ret < 0) {
 663                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 664                            "device_create_file error: %d",
 665                            ret);
 666         } else {
 667                 sfp->v4l_radio_minor_number_created_ok = !0;
 668         }
 669
 670         sysfs_attr_init(&sfp->attr_unit_number.attr);
 671         sfp->attr_unit_number.attr.name = "unit_number";
 672         sfp->attr_unit_number.attr.mode = S_IRUGO;
 673         sfp->attr_unit_number.show = unit_number_show;
 674         sfp->attr_unit_number.store = NULL;
 675         ret = device_create_file(sfp->class_dev,&sfp->attr_unit_number);
 676         if (ret < 0) {
 677                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 678                            "device_create_file error: %d",
 679                            ret);
 680         } else {
 681                 sfp->unit_number_created_ok = !0;
 682         }
 683
 684         sysfs_attr_init(&sfp->attr_bus_info.attr);
 685         sfp->attr_bus_info.attr.name = "bus_info_str";
 686         sfp->attr_bus_info.attr.mode = S_IRUGO;
 687         sfp->attr_bus_info.show = bus_info_show;
 688         sfp->attr_bus_info.store = NULL;
 689         ret = device_create_file(sfp->class_dev,
 690                                        &sfp->attr_bus_info);
 691         if (ret < 0) {
 692                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 693                            "device_create_file error: %d",
 694                            ret);
 695         } else {
 696                 sfp->bus_info_created_ok = !0;
 697         }
 698
 699         sysfs_attr_init(&sfp->attr_hdw_name.attr);
 700         sfp->attr_hdw_name.attr.name = "device_hardware_type";
 701         sfp->attr_hdw_name.attr.mode = S_IRUGO;
 702         sfp->attr_hdw_name.show = hdw_name_show;
 703         sfp->attr_hdw_name.store = NULL;
 704         ret = device_create_file(sfp->class_dev,
 705                                  &sfp->attr_hdw_name);
 706         if (ret < 0) {
 707                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 708                            "device_create_file error: %d",
 709                            ret);
 710         } else {
 711                 sfp->hdw_name_created_ok = !0;
 712         }
 713
 714         sysfs_attr_init(&sfp->attr_hdw_desc.attr);
 715         sfp->attr_hdw_desc.attr.name = "device_hardware_description";
 716         sfp->attr_hdw_desc.attr.mode = S_IRUGO;
 717         sfp->attr_hdw_desc.show = hdw_desc_show;
 718         sfp->attr_hdw_desc.store = NULL;
 719         ret = device_create_file(sfp->class_dev,
 720                                  &sfp->attr_hdw_desc);
 721         if (ret < 0) {
 722                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 723                            "device_create_file error: %d",
 724                            ret);
 725         } else {
 726                 sfp->hdw_desc_created_ok = !0;
 727         }
 728
 729         pvr2_sysfs_add_controls(sfp);
 730 #ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
 731         pvr2_sysfs_add_debugifc(sfp);
 732 #endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
 733 }
 734
 735
 736 static void pvr2_sysfs_internal_check(struct pvr2_channel *chp)
 737 {
 738         struct pvr2_sysfs *sfp;
 739         sfp = container_of(chp,struct pvr2_sysfs,channel);
 740         if (!sfp->channel.mc_head->disconnect_flag) return;
 741         pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_sysfs id=%p",sfp);
 742         class_dev_destroy(sfp);
 743         pvr2_channel_done(&sfp->channel);
 744         kfree(sfp);
 745 }
 746
 747
 748 void pvr2_sysfs_create(struct pvr2_context *mp)
 749 {
 750         struct pvr2_sysfs *sfp;
 751         sfp = kzalloc(sizeof(*sfp),GFP_KERNEL);
 752         if (!sfp)
 753                 return;
 754         pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_sysfs id=%p",sfp);
 755         pvr2_channel_init(&sfp->channel,mp);
 756         sfp->channel.check_func = pvr2_sysfs_internal_check;
 757
 758         class_dev_create(sfp);
 759 }
 760
 761
 762 void pvr2_sysfs_class_create(void)
 763 {
 764         if (class_register(&pvr2_class))
 765                 pvr2_sysfs_trace("Registration failed for pvr2_sysfs_class");
 766 }
 767
 768
 769 void pvr2_sysfs_class_destroy(void)
 770 {
 771         class_unregister(&pvr2_class);
 772 }
 773
 774
 775 #ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
 776 static ssize_t debuginfo_show(struct device *class_dev,
 777                               struct device_attribute *attr, char *buf)
 778 {
 779         struct pvr2_sysfs *sfp;
 780         sfp = dev_get_drvdata(class_dev);
 781         if (!sfp) return -EINVAL;
 782         pvr2_hdw_trigger_module_log(sfp->channel.hdw);
 783         return pvr2_debugifc_print_info(sfp->channel.hdw,buf,PAGE_SIZE);
 784 }
 785
 786
 787 static ssize_t debugcmd_show(struct device *class_dev,
 788                              struct device_attribute *attr, char *buf)
 789 {
 790         struct pvr2_sysfs *sfp;
 791         sfp = dev_get_drvdata(class_dev);
 792         if (!sfp) return -EINVAL;
 793         return pvr2_debugifc_print_status(sfp->channel.hdw,buf,PAGE_SIZE);
 794 }
 795
 796
 797 static ssize_t debugcmd_store(struct device *class_dev,
 798                               struct device_attribute *attr,
 799                               const char *buf, size_t count)
 800 {
 801         struct pvr2_sysfs *sfp;
 802         int ret;
 803
 804         sfp = dev_get_drvdata(class_dev);
 805         if (!sfp) return -EINVAL;
 806
 807         ret = pvr2_debugifc_docmd(sfp->channel.hdw,buf,count);
 808         if (ret < 0) return ret;
 809         return count;
 810 }
 811 #endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */