From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mx2.suse.de ([195.135.220.15]:50588 "EHLO mx2.suse.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750937AbeEGKFY (ORCPT ); Mon, 7 May 2018 06:05:24 -0400 Message-ID: <1525687128.24345.3.camel@suse.com> Subject: Re: [PATCH v3 1/2] usb: misc: xapea00x: add driver for Xaptum ENF Access Card From: Oliver Neukum To: "David R. Bild" , Peter Huewe , Jarkko Sakkinen , Greg Kroah-Hartman Cc: linux-integrity@vger.kernel.org, linux-usb@vger.kernel.org Date: Mon, 07 May 2018 11:58:48 +0200 In-Reply-To: <20180504130022.5231-2-david.bild@xaptum.com> References: <20180504130022.5231-1-david.bild@xaptum.com> <20180504130022.5231-2-david.bild@xaptum.com> Content-Type: text/plain; charset="UTF-8" Mime-Version: 1.0 Sender: linux-integrity-owner@vger.kernel.org List-ID: Am Freitag, den 04.05.2018, 08:00 -0500 schrieb David R. Bild : > > +config USB_XAPEA00X > + tristate "Xaptum ENF Access card support (XAP-EA-00x)" > + depends on USB_SUPPORT && SPI && TCG_TPM You'd have to know how the device internally works. It would be better to select SPI. > +static int xapea00x_br_bulk_write(struct xapea00x_device *dev, > + struct xapea00x_br_bulk_command *header, > + const void *data, int len) > +{ > + u8 *buf; > + unsigned int pipe; > + int buf_len, actual_len, retval; > + > + buf_len = sizeof(struct xapea00x_br_bulk_command) + len; > + buf = kzalloc(buf_len, GFP_KERNEL); > + if (!buf) { > + retval = -ENOMEM; > + goto out; > + } > + > + memcpy(buf, header, sizeof(struct xapea00x_br_bulk_command)); > + memcpy(buf + sizeof(struct xapea00x_br_bulk_command), data, len); > + > + pipe = usb_sndbulkpipe(dev->udev, dev->bulk_out->bEndpointAddress); > + retval = usb_bulk_msg(dev->udev, pipe, buf, buf_len, &actual_len, > + XAPEA00X_BR_USB_TIMEOUT); > + if (retval) > + goto free_buf; WTF? > +free_buf: > + kzfree(buf); > + > +out: > + return retval; > +} > + [..] > +static int xapea00x_spi_setup(struct spi_device *spi) > +{ > + struct xapea00x_device *dev; > + int retval; > + > + dev = spi_master_get_devdata(spi->master); > + > + mutex_lock(&dev->usb_mutex); > + if (!dev->interface) { > + retval = -ENODEV; > + goto out; > + } > + > + /* Verify that this is the TPM device */ > + if (spi->chip_select != 0) { > + retval = -EINVAL; > + goto err; > + } > + > + /* > + * Disable auto chip select for the TPM channel. > + * Must be done after setting the SPI parameters. > + */ > + retval = xapea00x_br_disable_cs(dev, 0); > + if (retval) > + goto err; > + > + /* De-assert chip select for the TPM channel. */ > + retval = xapea00x_br_deassert_cs(dev, 0); > + if (retval) > + goto err; > + > + goto out; > + > +err: > + dev_err(&dev->interface->dev, > + "configuring SPI channel failed with %d\n", retval); That could be a simple 'if' statement. > + > +out: > + mutex_unlock(&dev->usb_mutex); > + return retval; > +} > + > [..] > +/** > + * xapea00x_spi_probe - Register and configure the SPI master. > + * @dev: the device whose SPI master to register > + * > + * Return: If successful, 0. Otherwise a negative error number. > + */ > +static int xapea00x_spi_probe(struct xapea00x_device *dev) > +{ > + struct spi_master *spi_master; > + int retval; > + > + spi_master = spi_alloc_master(&dev->interface->dev, sizeof(void *)); > + if (!spi_master) { > + retval = -ENOMEM; > + goto err_out; > + } > + > + spi_master_set_devdata(spi_master, dev); > + > + spi_master->min_speed_hz = 93 * 1000 + 800; /* 93.9kHz */ > + spi_master->max_speed_hz = 12 * 1000 * 1000; /* 12 MHz */ > + > + spi_master->bus_num = -1; /* dynamically assigned */ > + spi_master->num_chipselect = 1; > + spi_master->mode_bits = SPI_MODE_0; > + > + spi_master->flags = 0; > + spi_master->setup = xapea00x_spi_setup; > + spi_master->transfer_one_message = xapea00x_spi_transfer_one_message; > + > + retval = spi_register_master(spi_master); > + > + if (retval) > + goto free_spi; > + > + dev->spi_master = spi_master; Race condition. > + > + return 0; > + > +free_spi: > + spi_master_put(spi_master); > + dev->spi_master = NULL; > + > +err_out: > + return retval; > +} > + > +struct xapea00x_async_probe { > + struct work_struct work; > + struct xapea00x_device *dev; > +}; > + > +#define work_to_probe(w) container_of(w, struct xapea00x_async_probe, work) > + > +/** > + * xapea00x_init_async_probe - initialize an async probe with the > + * specified values. > + * @probe: pointer to the async_probe to initialize > + * @dev: pointer to the device to probe > + * @f: pointer to the probe function > + */ > +static void xapea00x_init_async_probe(struct xapea00x_async_probe *probe, > + struct xapea00x_device *dev, > + void (*f)(struct work_struct *work)) > +{ > + INIT_WORK(&probe->work, f); > + probe->dev = dev; > + > + kref_get(&dev->kref); > + spi_master_get(dev->spi_master); > +} > + > +/** > + * xapea00x_cleanup_async_probe - clean up the internals of the async > + * probe. Call this method after the probe has completed. > + * > + * The caller is responsible for freeing the probe itself, if > + * dynamically allocated. > + * > + * @probe: pointer to the async_probe to clean up > + */ > +static void xapea00x_cleanup_async_probe(struct xapea00x_async_probe *probe) > +{ > + spi_master_put(probe->dev->spi_master); > + kref_put(&probe->dev->kref, xapea00x_delete); > +} > + > +static struct spi_board_info tpm_board_info = { > + .modalias = XAPEA00X_TPM_MODALIAS, > + .max_speed_hz = 43 * 1000 * 1000, // Hz Are you hardcoding HZ ? > + .chip_select = 0, > + .mode = SPI_MODE_0 > +}; Regards Oliver From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v3,1/2] usb: misc: xapea00x: add driver for Xaptum ENF Access Card From: Oliver Neukum Message-Id: <1525687128.24345.3.camel@suse.com> Date: Mon, 07 May 2018 11:58:48 +0200 To: "David R. Bild" , Peter Huewe , Jarkko Sakkinen , Greg Kroah-Hartman Cc: linux-integrity@vger.kernel.org, linux-usb@vger.kernel.org List-ID: QW0gRnJlaXRhZywgZGVuIDA0LjA1LjIwMTgsIDA4OjAwIC0wNTAwIHNjaHJpZWIgIERhdmlkIFIu IEJpbGQgOgo+IAo+ICtjb25maWcgVVNCX1hBUEVBMDBYCj4gKwl0cmlzdGF0ZSAiWGFwdHVtIEVO RiBBY2Nlc3MgY2FyZCBzdXBwb3J0IChYQVAtRUEtMDB4KSIKPiArCWRlcGVuZHMgb24gVVNCX1NV UFBPUlQgJiYgU1BJICYmIFRDR19UUE0KCllvdSdkIGhhdmUgdG8ga25vdyBob3cgdGhlIGRldmlj ZSBpbnRlcm5hbGx5IHdvcmtzLiBJdCB3b3VsZCBiZSBiZXR0ZXIKdG8gc2VsZWN0IFNQSS4KCj4g K3N0YXRpYyBpbnQgeGFwZWEwMHhfYnJfYnVsa193cml0ZShzdHJ1Y3QgeGFwZWEwMHhfZGV2aWNl ICpkZXYsCj4gKwkJCQkgIHN0cnVjdCB4YXBlYTAweF9icl9idWxrX2NvbW1hbmQgKmhlYWRlciwK PiArCQkJCSAgY29uc3Qgdm9pZCAqZGF0YSwgaW50IGxlbikKPiArewo+ICsJdTggKmJ1ZjsKPiAr CXVuc2lnbmVkIGludCBwaXBlOwo+ICsJaW50IGJ1Zl9sZW4sIGFjdHVhbF9sZW4sIHJldHZhbDsK PiArCj4gKwlidWZfbGVuID0gc2l6ZW9mKHN0cnVjdCB4YXBlYTAweF9icl9idWxrX2NvbW1hbmQp ICsgbGVuOwo+ICsJYnVmID0ga3phbGxvYyhidWZfbGVuLCBHRlBfS0VSTkVMKTsKPiArCWlmICgh YnVmKSB7Cj4gKwkJcmV0dmFsID0gLUVOT01FTTsKPiArCQlnb3RvIG91dDsKPiArCX0KPiArCj4g KwltZW1jcHkoYnVmLCBoZWFkZXIsIHNpemVvZihzdHJ1Y3QgeGFwZWEwMHhfYnJfYnVsa19jb21t YW5kKSk7Cj4gKwltZW1jcHkoYnVmICsgc2l6ZW9mKHN0cnVjdCB4YXBlYTAweF9icl9idWxrX2Nv bW1hbmQpLCBkYXRhLCBsZW4pOwo+ICsKPiArCXBpcGUgPSB1c2Jfc25kYnVsa3BpcGUoZGV2LT51 ZGV2LCBkZXYtPmJ1bGtfb3V0LT5iRW5kcG9pbnRBZGRyZXNzKTsKPiArCXJldHZhbCA9IHVzYl9i dWxrX21zZyhkZXYtPnVkZXYsIHBpcGUsIGJ1ZiwgYnVmX2xlbiwgJmFjdHVhbF9sZW4sCj4gKwkJ CSAgICAgIFhBUEVBMDBYX0JSX1VTQl9USU1FT1VUKTsKPiArCWlmIChyZXR2YWwpCj4gKwkJZ290 byBmcmVlX2J1ZjsKCldURj8KCj4gK2ZyZWVfYnVmOgo+ICsJa3pmcmVlKGJ1Zik7Cj4gKwo+ICtv dXQ6Cj4gKwlyZXR1cm4gcmV0dmFsOwo+ICt9Cj4gKwoKWy4uXQo+ICtzdGF0aWMgaW50IHhhcGVh MDB4X3NwaV9zZXR1cChzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpKQo+ICt7Cj4gKwlzdHJ1Y3QgeGFw ZWEwMHhfZGV2aWNlICpkZXY7Cj4gKwlpbnQgcmV0dmFsOwo+ICsKPiArCWRldiA9IHNwaV9tYXN0 ZXJfZ2V0X2RldmRhdGEoc3BpLT5tYXN0ZXIpOwo+ICsKPiArCW11dGV4X2xvY2soJmRldi0+dXNi X211dGV4KTsKPiArCWlmICghZGV2LT5pbnRlcmZhY2UpIHsKPiArCQlyZXR2YWwgPSAtRU5PREVW Owo+ICsJCWdvdG8gb3V0Owo+ICsJfQo+ICsKPiArCS8qIFZlcmlmeSB0aGF0IHRoaXMgaXMgdGhl IFRQTSBkZXZpY2UgKi8KPiArCWlmIChzcGktPmNoaXBfc2VsZWN0ICE9IDApIHsKPiArCQlyZXR2 YWwgPSAtRUlOVkFMOwo+ICsJCWdvdG8gZXJyOwo+ICsJfQo+ICsKPiArCS8qCj4gKwkgKiBEaXNh YmxlIGF1dG8gY2hpcCBzZWxlY3QgZm9yIHRoZSBUUE0gY2hhbm5lbC4KPiArCSAqIE11c3QgYmUg ZG9uZSBhZnRlciBzZXR0aW5nIHRoZSBTUEkgcGFyYW1ldGVycy4KPiArCSAqLwo+ICsJcmV0dmFs ID0geGFwZWEwMHhfYnJfZGlzYWJsZV9jcyhkZXYsIDApOwo+ICsJaWYgKHJldHZhbCkKPiArCQln b3RvIGVycjsKPiArCj4gKwkvKiBEZS1hc3NlcnQgY2hpcCBzZWxlY3QgZm9yIHRoZSBUUE0gY2hh bm5lbC4gKi8KPiArCXJldHZhbCA9IHhhcGVhMDB4X2JyX2RlYXNzZXJ0X2NzKGRldiwgMCk7Cj4g KwlpZiAocmV0dmFsKQo+ICsJCWdvdG8gZXJyOwo+ICsKPiArCWdvdG8gb3V0Owo+ICsKPiArZXJy Ogo+ICsJZGV2X2VycigmZGV2LT5pbnRlcmZhY2UtPmRldiwKPiArCQkiY29uZmlndXJpbmcgU1BJ IGNoYW5uZWwgZmFpbGVkIHdpdGggJWRcbiIsIHJldHZhbCk7CgpUaGF0IGNvdWxkIGJlIGEgc2lt cGxlICdpZicgc3RhdGVtZW50Lgo+ICsKPiArb3V0Ogo+ICsJbXV0ZXhfdW5sb2NrKCZkZXYtPnVz Yl9tdXRleCk7Cj4gKwlyZXR1cm4gcmV0dmFsOwo+ICt9Cj4gKwo+IAoKWy4uXQo+ICsvKioKPiAr ICogeGFwZWEwMHhfc3BpX3Byb2JlIC0gUmVnaXN0ZXIgYW5kIGNvbmZpZ3VyZSB0aGUgU1BJIG1h c3Rlci4KPiArICogQGRldjogdGhlIGRldmljZSB3aG9zZSBTUEkgbWFzdGVyIHRvIHJlZ2lzdGVy Cj4gKyAqCj4gKyAqIFJldHVybjogSWYgc3VjY2Vzc2Z1bCwgMC4gT3RoZXJ3aXNlIGEgbmVnYXRp dmUgZXJyb3IgbnVtYmVyLgo+ICsgKi8KPiArc3RhdGljIGludCB4YXBlYTAweF9zcGlfcHJvYmUo c3RydWN0IHhhcGVhMDB4X2RldmljZSAqZGV2KQo+ICt7Cj4gKwlzdHJ1Y3Qgc3BpX21hc3RlciAq c3BpX21hc3RlcjsKPiArCWludCByZXR2YWw7Cj4gKwo+ICsJc3BpX21hc3RlciA9IHNwaV9hbGxv Y19tYXN0ZXIoJmRldi0+aW50ZXJmYWNlLT5kZXYsIHNpemVvZih2b2lkICopKTsKPiArCWlmICgh c3BpX21hc3Rlcikgewo+ICsJCXJldHZhbCA9IC1FTk9NRU07Cj4gKwkJZ290byBlcnJfb3V0Owo+ ICsJfQo+ICsKPiArCXNwaV9tYXN0ZXJfc2V0X2RldmRhdGEoc3BpX21hc3RlciwgZGV2KTsKPiAr Cj4gKwlzcGlfbWFzdGVyLT5taW5fc3BlZWRfaHogPSA5MyAqIDEwMDAgKyA4MDA7IC8qIDkzLjlr SHogKi8KPiArCXNwaV9tYXN0ZXItPm1heF9zcGVlZF9oeiA9IDEyICogMTAwMCAqIDEwMDA7IC8q IDEyIE1IeiAqLwo+ICsKPiArCXNwaV9tYXN0ZXItPmJ1c19udW0gPSAtMTsgLyogZHluYW1pY2Fs bHkgYXNzaWduZWQgKi8KPiArCXNwaV9tYXN0ZXItPm51bV9jaGlwc2VsZWN0ID0gMTsKPiArCXNw aV9tYXN0ZXItPm1vZGVfYml0cyA9IFNQSV9NT0RFXzA7Cj4gKwo+ICsJc3BpX21hc3Rlci0+Zmxh Z3MgPSAwOwo+ICsJc3BpX21hc3Rlci0+c2V0dXAgPSB4YXBlYTAweF9zcGlfc2V0dXA7Cj4gKwlz cGlfbWFzdGVyLT50cmFuc2Zlcl9vbmVfbWVzc2FnZSA9IHhhcGVhMDB4X3NwaV90cmFuc2Zlcl9v bmVfbWVzc2FnZTsKPiArCj4gKwlyZXR2YWwgPSBzcGlfcmVnaXN0ZXJfbWFzdGVyKHNwaV9tYXN0 ZXIpOwo+ICsKPiArCWlmIChyZXR2YWwpCj4gKwkJZ290byBmcmVlX3NwaTsKPiArCj4gKwlkZXYt PnNwaV9tYXN0ZXIgPSBzcGlfbWFzdGVyOwoKUmFjZSBjb25kaXRpb24uCgo+ICsKPiArCXJldHVy biAwOwo+ICsKPiArZnJlZV9zcGk6Cj4gKwlzcGlfbWFzdGVyX3B1dChzcGlfbWFzdGVyKTsKPiAr CWRldi0+c3BpX21hc3RlciA9IE5VTEw7Cj4gKwo+ICtlcnJfb3V0Ogo+ICsJcmV0dXJuIHJldHZh bDsKPiArfQo+ICsKPiArc3RydWN0IHhhcGVhMDB4X2FzeW5jX3Byb2JlIHsKPiArCXN0cnVjdCB3 b3JrX3N0cnVjdCB3b3JrOwo+ICsJc3RydWN0IHhhcGVhMDB4X2RldmljZSAqZGV2Owo+ICt9Owo+ ICsKPiArI2RlZmluZSB3b3JrX3RvX3Byb2JlKHcpIGNvbnRhaW5lcl9vZih3LCBzdHJ1Y3QgeGFw ZWEwMHhfYXN5bmNfcHJvYmUsIHdvcmspCj4gKwo+ICsvKioKPiArICogeGFwZWEwMHhfaW5pdF9h c3luY19wcm9iZSAtIGluaXRpYWxpemUgYW4gYXN5bmMgcHJvYmUgd2l0aCB0aGUKPiArICogc3Bl Y2lmaWVkIHZhbHVlcy4KPiArICogQHByb2JlOiBwb2ludGVyIHRvIHRoZSBhc3luY19wcm9iZSB0 byBpbml0aWFsaXplCj4gKyAqIEBkZXY6IHBvaW50ZXIgdG8gdGhlIGRldmljZSB0byBwcm9iZQo+ ICsgKiBAZjogcG9pbnRlciB0byB0aGUgcHJvYmUgZnVuY3Rpb24KPiArICovCj4gK3N0YXRpYyB2 b2lkIHhhcGVhMDB4X2luaXRfYXN5bmNfcHJvYmUoc3RydWN0IHhhcGVhMDB4X2FzeW5jX3Byb2Jl ICpwcm9iZSwKPiArCQkJCSAgICAgIHN0cnVjdCB4YXBlYTAweF9kZXZpY2UgKmRldiwKPiArCQkJ CSAgICAgIHZvaWQgKCpmKShzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspKQo+ICt7Cj4gKwlJTklU X1dPUksoJnByb2JlLT53b3JrLCBmKTsKPiArCXByb2JlLT5kZXYgPSBkZXY7Cj4gKwo+ICsJa3Jl Zl9nZXQoJmRldi0+a3JlZik7Cj4gKwlzcGlfbWFzdGVyX2dldChkZXYtPnNwaV9tYXN0ZXIpOwo+ ICt9Cj4gKwo+ICsvKioKPiArICogeGFwZWEwMHhfY2xlYW51cF9hc3luY19wcm9iZSAtIGNsZWFu IHVwIHRoZSBpbnRlcm5hbHMgb2YgdGhlIGFzeW5jCj4gKyAqIHByb2JlLiBDYWxsIHRoaXMgbWV0 aG9kIGFmdGVyIHRoZSBwcm9iZSBoYXMgY29tcGxldGVkLgo+ICsgKgo+ICsgKiBUaGUgY2FsbGVy IGlzIHJlc3BvbnNpYmxlIGZvciBmcmVlaW5nIHRoZSBwcm9iZSBpdHNlbGYsIGlmCj4gKyAqIGR5 bmFtaWNhbGx5IGFsbG9jYXRlZC4KPiArICoKPiArICogQHByb2JlOiBwb2ludGVyIHRvIHRoZSBh c3luY19wcm9iZSB0byBjbGVhbiB1cAo+ICsgKi8KPiArc3RhdGljIHZvaWQgeGFwZWEwMHhfY2xl YW51cF9hc3luY19wcm9iZShzdHJ1Y3QgeGFwZWEwMHhfYXN5bmNfcHJvYmUgKnByb2JlKQo+ICt7 Cj4gKwlzcGlfbWFzdGVyX3B1dChwcm9iZS0+ZGV2LT5zcGlfbWFzdGVyKTsKPiArCWtyZWZfcHV0 KCZwcm9iZS0+ZGV2LT5rcmVmLCB4YXBlYTAweF9kZWxldGUpOwo+ICt9Cj4gKwo+ICtzdGF0aWMg c3RydWN0IHNwaV9ib2FyZF9pbmZvIHRwbV9ib2FyZF9pbmZvID0gewo+ICsJLm1vZGFsaWFzCT0g WEFQRUEwMFhfVFBNX01PREFMSUFTLAo+ICsJLm1heF9zcGVlZF9oegk9IDQzICogMTAwMCAqIDEw MDAsIC8vIEh6CgpBcmUgeW91IGhhcmRjb2RpbmcgSFogPwoKPiArCS5jaGlwX3NlbGVjdAk9IDAs Cj4gKwkubW9kZQkJPSBTUElfTU9ERV8wCj4gK307CgoJUmVnYXJkcwoJCU9saXZlcgotLS0KVG8g dW5zdWJzY3JpYmUgZnJvbSB0aGlzIGxpc3Q6IHNlbmQgdGhlIGxpbmUgInVuc3Vic2NyaWJlIGxp bnV4LXVzYiIgaW4KdGhlIGJvZHkgb2YgYSBtZXNzYWdlIHRvIG1ham9yZG9tb0B2Z2VyLmtlcm5l bC5vcmcKTW9yZSBtYWpvcmRvbW8gaW5mbyBhdCAgaHR0cDovL3ZnZXIua2VybmVsLm9yZy9tYWpv cmRvbW8taW5mby5odG1sCg==